{"id":51298076,"url":"https://github.com/alexeyev/refalcon","last_synced_at":"2026-06-30T16:32:15.909Z","repository":{"id":364625305,"uuid":"1264389072","full_name":"alexeyev/refalcon","owner":"alexeyev","description":"IntelliJ IDEA Plugin for Refal 5λ (+Refal-2 and Refal-5)","archived":false,"fork":false,"pushed_at":"2026-06-13T19:03:33.000Z","size":193,"stargazers_count":1,"open_issues_count":0,"forks_count":0,"subscribers_count":0,"default_branch":"main","last_synced_at":"2026-06-13T20:25:55.175Z","etag":null,"topics":["intellij-idea-plugin","intellij-plugin","oldschool","refal-5-lambda","refal-lang","refal5","retrocoding","term-rewriting"],"latest_commit_sha":null,"homepage":"","language":"Java","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/alexeyev.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null}},"created_at":"2026-06-09T20:55:24.000Z","updated_at":"2026-06-13T19:19:51.000Z","dependencies_parsed_at":null,"dependency_job_id":null,"html_url":"https://github.com/alexeyev/refalcon","commit_stats":null,"previous_names":["alexeyev/refalcon"],"tags_count":2,"template":false,"template_full_name":null,"purl":"pkg:github/alexeyev/refalcon","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/alexeyev%2Frefalcon","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/alexeyev%2Frefalcon/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/alexeyev%2Frefalcon/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/alexeyev%2Frefalcon/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/alexeyev","download_url":"https://codeload.github.com/alexeyev/refalcon/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/alexeyev%2Frefalcon/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":34975669,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-05-26T15:22:16.424Z","status":"online","status_checked_at":"2026-06-30T02:00:05.919Z","response_time":92,"last_error":null,"robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":true,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["intellij-idea-plugin","intellij-plugin","oldschool","refal-5-lambda","refal-lang","refal5","retrocoding","term-rewriting"],"created_at":"2026-06-30T16:32:15.361Z","updated_at":"2026-06-30T16:32:15.872Z","avatar_url":"https://github.com/alexeyev.png","language":"Java","funding_links":[],"categories":[],"sub_categories":[],"readme":"# Refalcon — a Refal-5λ plugin for IntelliJ IDEA\n\nAn IntelliJ Platform plugin that makes IntelliJ IDEA **recognize, highlight, and run\nRefal-5 Lambda** source files (`.ref`, `.refi`).\n\n## Features\n\n**Syntax highlighting** (lexer-based):\n- directives / keywords: `$ENTRY`, `$EXTERN`, `$EXTRN`, `$EXTERNAL`, `$EASTEREGG`,\n  `$ENUM`, `$EENUM`, `$SWAP`, `$ESWAP`, `$SCOPEID`, `$DRIVE`, `$INLINE`, `$SPEC`, `$INCLUDE`\n  (unknown `$WORD`s are flagged)\n- variables `s.X` / `t.X` / `e.X`\n- single- and double-quoted strings, **with escape highlighting** inside them\n  (`\\n \\r \\t \\\\ \\' \\\" \\\u003c \\\u003e \\( \\)` and `\\xHH` shown as valid; anything else as an invalid escape)\n- numbers (macrodigits)\n- line comments (`*` in the first column) and block comments (`/* … */`)\n- embedded native blocks (`%% … %%`)\n- function **definitions** (a name immediately before `{`) vs function **calls**\n  (a name immediately after `\u003c` or `[`)\n- brackets `( )`, `{ }`, `\u003c \u003e`, `[ ]`, plus `;` `,` `:` `=`\n\n**Editor integration:**\n- a configurable **Color Settings** page (Settings → Editor → Color Scheme → Refal-5 Lambda)\n- **brace matching** for `{ } ( ) \u003c \u003e [ ]`\n- **comment toggling** (block comments via Code → Comment with Block Comment)\n\n**Code intelligence** (PSI/parser-based):\n- a **Structure view** (the file-structure popup, Ctrl/Cmd+F12) listing the functions defined in the file\n- **code folding** for function bodies `{ … }`, block comments, and `%% … %%` native blocks\n- basic **code completion** (Ctrl+Space) for directive keywords, common built-in functions,\n  function names defined in the current file, and the `s.`/`t.`/`e.` variables in scope\n- **navigation \u0026 refactoring**: Go to Declaration (Ctrl/Cmd+click a call jumps to its definition —\n  in the same file, or another project file declared via `$EXTERN`), **Go to Symbol**\n  (Ctrl+Alt+Shift+N / Cmd+Opt+O — jump to any function in the project by fuzzy name),\n  Find Usages (Alt/Opt+F7), and\n  Rename (Shift+F6) — renaming a function updates all of its calls across the project\n- **Duplicate-function inspection**: flags a function name defined more than once in a file\n  (a redefinition the compiler would reject), highlighting every clashing definition\n- **TODO / FIXME** markers inside Refal comments light up and appear in the TODO tool window\n  (both dialects)\n- **Breadcrumbs** show the enclosing function while scrolling a long file (both dialects)\n- **Live templates**: `entry`, `fn`, `call`, `extern`, `prout`, `proutq` expand with Tab;\n  **File → New → Refal File** starts from a runnable skeleton\n- **Unreachable-sentence inspection**: Refal tries sentences in order, and a lone `e.X`\n  pattern matches anything — sentences after it are dead code. Flagged narrowly: parentheses,\n  extra variables/symbols, or a where-clause make the pattern fallible and are never reported\n- **Unused function inspection** (Settings → Editor → Inspections → Refal): grays out functions\n  nothing calls — conservatively: `$ENTRY` functions and `Go`/`GO` are exported/entry API and are\n  never flagged, and cross-file usage is checked before reporting; also runs in batch via\n  Code → Inspect Code\n- **formatting**: Reformat Code (Ctrl+Alt+L / Cmd+Opt+L) with the canonical 2-space Refal style;\n  continuation lines (leading `=` / `,`) indent one extra level, spacing around `=` `:` `,` `;`\n  and inside `\u003c \u003e` `( )` is normalized, and your line structure is preserved. Column-0 `*`\n  comments are pinned — indenting them would turn them into code, so the formatter never does\n- **quick documentation** (Ctrl/Cmd+Q, or hover): built-in functions show a short description;\n  functions defined in the file show their header\n- **instant error highlighting** (no compiler needed) with **quick-fixes** — Alt+Enter on an\n  unresolved call offers *Create function* or *Add `$EXTERN`*: an undefined function call (not a built-in,\n  standard-library, defined, or `$EXTERN`-declared name) is flagged as *Unresolved function*, and a\n  variable used on the result side that the pattern never binds is flagged as *Unresolved variable*.\n  This works as you type and complements the full `rlc` diagnostics below. The idea is borrowed from\n  the Grammar-Kit-based coursework plugin\n  [bmstu-iu9/RefalFiveLambdaPlugin](https://github.com/bmstu-iu9/RefalFiveLambdaPlugin)\n  (re-implemented here on this plugin's own grammar, kept conservative to avoid false positives).\n\n**Run support:** a \"Refal-5λ\" run configuration that compiles a `.ref` file with the Refal-5λ\ncompiler (`rlc`) and, by default, runs the resulting executable — output streams to the Run console.\nThe compiler is **auto-detected** on your `PATH` (and common install dirs), a green **run arrow**\nappears next to the `Go`/`GO` entry function, and compiler diagnostics like `file.ref:line:col`\nbecome **clickable links** in the Run console (absolute Windows paths included). If `rlc` is\nfound, the compiler also runs a fast `--grammar-check` (syntax-only, no artifacts, no C++\ntoolchain needed) in the background and shows its **errors inline** in the editor.\n\n**Boilerplate:** a *New → Refal File* entry that seeds a runnable skeleton, plus live templates —\ntype `entry`, `fn`, or `prout` and press Tab to expand the program entry point, a function, or a\n`\u003cProut …\u003e` call.\n\n## Dialects: classic Refal-5 and Refal-2\n\nRefalcon targets Refal-5λ, but `.ref` belongs to the whole family, so the plugin understands\nits relatives too:\n\n- **Classic Refal-5** works as-is — the λ syntax is a superset for editor purposes. `$ENTRY` /\n  `$EXTRN` / `$EXTERNAL` directives, `s.X`/`t.X`/`e.X` variables and column-0 `*` comments are\n  native here, and the classic built-ins (`Card`, `Print`, `Mu`, `Br`, `Dg`, …) are already in\n  the completion list and the resolver's known set.\n- **Refal-2** files are detected by content, because extensions cannot help: the historic\n  refal2-0.2.3 distribution uses `.ref` as well (verified against its sources). A `name start`\n  module header, bare `entry`/`extrn` directives, or a `k/name/` call switch the file to a\n  dedicated Refal-2 lexer and parser. Detection is content-aware: strings and comments are\n  ignored (so a `k/...` inside a string or comment can't misfire), and a `$`-directive or a brace\n  block — neither of which exists in Refal-2 — marks the file as Refal-5/5λ. When detection would\n  be ambiguous (e.g. a Refal-2 fragment with no module header), a standalone comment **`* refal-2`**\n  (or `* refal-5` / `* dialect: refal-2`) at the top forces the dialect deterministically. Each\n  dialect also has its **own file icon** — a green \"2\" glyph for Refal-2, the blue glyph for\n  Refal-5λ. What works:\n  full highlighting (`/123/` macrodigits, `s1s2s3` variable chains, `V(D)X` specifier\n  variables, `+` line continuations, both call notations `\u003cName …\u003e` and `k/name/ … .`),\n  brace matching for `( )`, `\u003c \u003e` and `k/ … .`, the structure view, comment toggling, find\n  usages, rename, and **case-insensitive** go-to-definition (`extrn print` ↔ `\u003cPrint …\u003e`,\n  exactly as the real sources do) — in-file and across the project's Refal-2 files. Refal-2\n  functions also appear in Navigate → Symbol….\n\nHonest limits for Refal-2: no completion, formatter, run configuration, or λ-specific\ninspections — dialect support is deliberately compiler-independent. Rename and find-usages\nmatch exact case (the word index is case-sensitive) while navigation resolves\ncase-insensitively. Grounding: the refal2-0.2.3 distribution's test programs and `xcv.ref`,\nplus its manual.\n\n## Requirements\n\n- IntelliJ IDEA **2024.3 or newer** (Community or Ultimate); it also loads on 2025.x+.\n- **JDK 21** to build (the Gradle wrapper auto-provisions Gradle 9.5.1; a JDK 21 toolchain can be\n  auto-downloaded if you don't have one).\n- To actually run programs: the **Refal-5λ toolchain** (`rlc` / `rlmake`) on your machine —\n  see https://github.com/bmstu-iu9/refal-5-lambda.\n\n## Get IntelliJ IDEA Community Edition (open source, from GitHub)\n\nJetBrains publishes IntelliJ IDEA Community Edition as Apache-2.0 **source code** (not prebuilt\nbinaries) at [github.com/JetBrains/intellij-community](https://github.com/JetBrains/intellij-community).\nTo get a runnable IDE you build it:\n\n1. Pick the branch for the version you want — branch names match build numbers, e.g. `243` for\n   2024.3 (`master` is the next major release).\n2. Shallow-clone that branch (saves a lot of time):\n   `git clone --depth 1 -b 243 https://github.com/JetBrains/intellij-community.git`\n3. Build the installers with `installers.cmd` (works on Windows and Unix; a Docker build is also\n   provided), **or** open the sources in an existing IntelliJ and use *Build → Build Project* plus\n   the preconfigured **IDEA** run configuration to launch it.\n\n(The ready-made installers on jetbrains.com are the same product through a separate, non-GitHub\nchannel.)\n\n## Install the plugin\n\nGet `refalcon-\u003cversion\u003e.zip` — from a GitHub Release, or build it (see below). Then in the IDE:\n**Settings → Plugins → ⚙ → Install Plugin from Disk…**, choose the zip, and restart. Open a `.ref`\nfile such as `examples/hello.ref` to confirm highlighting works.\n\n## Build from source\n\n```bash\n./gradlew buildPlugin           # -\u003e build/distributions/refalcon-\u003cversion\u003e.zip\n```\n\nThis produces the installable zip (install it as above). To try the plugin in a throwaway sandbox\nIDE instead, run `./gradlew runIde`.\n\n## Install from a plugin repository (one-click, with auto-updates)\n\nFor installs and updates without the Marketplace (and without a JetBrains account), the project\npublishes its own **custom plugin repository** via GitHub Releases + GitHub Pages.\n\nOne-time setup (maintainer): in the repo, enable **Settings → Pages → Source: GitHub Actions**.\nThen each `git tag vX.Y.Z \u0026\u0026 git push --tags` runs `.github/workflows/release.yml`, which builds the\nplugin, attaches the zip to a GitHub Release, and publishes an `updatePlugins.xml` to Pages at\n`https://\u003cowner\u003e.github.io/\u003crepo\u003e/updatePlugins.xml`.\n\nOne-time setup (user): **Settings → Plugins → ⚙ → Manage Plugin Repositories…**, add that\n`updatePlugins.xml` URL, then install \"Refalcon\" from the Marketplace tab. After that the IDE\noffers updates automatically whenever you publish a new tag.\n\n\u003e Before publishing, set the `\u003cvendor\u003e` (and optionally its `url`) in\n\u003e `src/main/resources/META-INF/plugin.xml`.\n\n## Install the Refal compiler (rlc)\n\nThe plugin itself needs nothing extra — highlighting, completion, navigation and the instant\nerror checks all work out of the box. Installing `rlc` additionally enables the inline compiler\ndiagnostics and the Run button.\n\n**Windows (easiest):** download `setup-refal-5-lambda-\u003cversion\u003e.exe` from the\n[latest release](https://github.com/bmstu-iu9/refal-5-lambda/releases/latest) and run it — it\nunpacks the toolchain into your user profile and adds it to your `PATH`. **No C++ compiler is\nneeded on Windows**: by default programs link against prebuilt runtime *prefixes* (`slim`/`rich`)\nshipped with the installer (verified from the toolchain's own `rlc.bat`, which passes\n`--exesuffix=.exe` and an empty C++ command in this mode). **Then restart the IDE**: a running\nIDE keeps the `PATH` it started with and will not see a freshly installed `rlc`.\n\n**Linux / macOS:**\n\nmacOS is officially supported (the toolchain's own CI builds on it); building needs a C++\ncompiler — on macOS install the Xcode Command Line Tools first (`xcode-select --install`),\non Linux `g++` from your package manager.\n\n```bash\ngit clone https://github.com/bmstu-iu9/refal-5-lambda\ncd refal-5-lambda \u0026\u0026 ./bootstrap.sh     # builds the toolchain with your C++ compiler\n# then add its bin/ to PATH (the official docs also set RL_MODULE_PATH to the same dir)\n```\n\nIf you clone into your home directory, the plugin auto-detects `~/refal-5-lambda/bin` (and\n`~/simple-refal-distrib/bin`) even before you update `PATH`.\n\nOpen a **new** terminal and type `rlc` to verify (it prints usage). The plugin **auto-detects**\n`rlc` on the `PATH` and in standard install locations; you can always override it per run\nconfiguration via the **\"Refal compiler (rlc)\"** field.\n\n**Troubleshooting — `'rlc' is not recognized as an internal or external command`:** on Windows the\ntoolchain ships **`rlc.bat`** (no `rlc.exe`), installed to **`%APPDATA%\\Refal-5-lambda\\bin`** —\nverified by inspecting the official installer. The plugin auto-detects it there *even if the\nIDE's `PATH` is stale*. If the shell still can't find it: restart the IDE after installing —\nand **restart JetBrains Toolbox too** if you launch through it (IDEs inherit Toolbox's old\n`PATH`) — or put the full path (e.g. `%APPDATA%\\Refal-5-lambda\\bin\\rlc.bat`) into the run\nconfiguration's compiler field. On a genuine \"command not found\" exit, the Run console now\nappends these exact instructions.\n\n## Running a Refal program\n\nThe Refal-5λ compiler turns a `.ref` file into a native OS executable (no separate interpreter).\nThis plugin's run configuration drives that:\n\n1. Open a `.ref` file (or right-click it / press Ctrl+Shift+F10) and choose **Run** — a\n   \"Refal-5λ\" configuration is created with the file prefilled.\n2. In the configuration you can set:\n   - **Refal compiler (rlc)** — path to the compiler. Leave it **empty to auto-detect**\n     (`PATH` + standard install locations); set it only to pin a specific binary.\n   - **Build with rlmake** — check this for multi-file programs: `rlmake` follows `*$FROM Unit`\n     comments, compiles every dependent unit automatically, and links a single executable named\n     after the main file (verified against the real toolchain; on Windows `rlmake.bat` ships\n     alongside `rlc.bat` and is auto-detected the same way).\n   - **Compiler options** — extra flags passed to the compiler.\n   - **Refal file** — the `.ref` source.\n   - **Run the compiled executable after a successful compile** — when on, the produced binary is\n     executed right after compilation.\n   - **Output executable** — the produced binary (defaults to the source base name, run as\n     `./name` on macOS/Linux or `name.exe` on Windows).\n   - **Program arguments** — passed to your compiled program.\n   - **Working directory** — defaults to the source file's folder.\n\nWhen \"run after compile\" is on, the two steps are chained through your OS shell\n(`rlc … \u0026\u0026 ./program …`). Turn it off to only compile. If your build is more involved, point the\ncompiler field at `rlmake` or at your own script.\n\n## Verify the plugin works\n\nInstall the plugin (above), then open the bundled examples: `examples/hello.ref` (a small, runnable\nprogram) and `examples/showcase.ref` (which deliberately contains the tricky cases). Use\n`hello.ref` unless a step says otherwise.\n\n1. **Highlighting** — `$ENTRY`/`$EXTERN` (keyword), `s.N`/`e.Name` (variables), strings, numbers,\n   `*` and `/* */` comments, and function names vs. calls are all colored.\n2. **Escapes** — in a string, `\\n` `\\t` `\\x41` show the *valid-escape* color; open `showcase.ref`\n   to see `\\q`/`\\x` in the *invalid* color and `$FOOBAR` flagged as an unknown directive.\n3. **Brace matching** — put the caret next to `{`, `(`, `\u003c`, or `[`; its partner is highlighted.\n4. **Folding** — click the gutter arrow by a `{` to fold a function body; block comments and the\n   `%% %%` block (in `showcase.ref`) fold too.\n5. **Structure view** — press Ctrl/Cmd+F12: you should see `Go`, `Fact`, `Greet`.\n6. **Completion** — type `\u003c` then Ctrl+Space: the list offers `$`-directives, common built-ins\n   (`Prout`, `Mul`, `Sub`, `Symb`, …), and the file's own function names.\n7. **Run** — right-click `hello.ref` → *Run 'hello'*. With `rlc` on your `PATH` it compiles and\n   runs, printing the greeting and `Factorial of 5 = 120` in the Run console. (A green arrow also\n   appears in the gutter next to `Go`.)\n8. **Navigation** — Ctrl/Cmd+click the `\u003cFact …\u003e` call to jump to the `Fact` definition;\n   press Shift+F6 on `Fact` to rename it and watch the call update; Alt/Opt+F7 lists its usages.\n9. **Docs \u0026 templates** — press Ctrl/Cmd+Q on `\u003cProut …\u003e` to see its description; in a new file,\n   type `entry` then Tab to expand the program skeleton (and try *New → Refal File* on a folder).\n\n## Project layout\n\n```\nsrc/main/java/com/github/refal5lambda/\n  RefalTokenKind.java / RefalScanner.java   pure, IntelliJ-free, unit-testable scanner\n  RefalLexer.java                            LexerBase adapter (carries string state)\n  RefalTokenTypes.java                       IElementType per kind + kind→type map\n  RefalLanguage.java / RefalFileType.java    language + .ref/.refi file type\n  RefalSyntaxHighlighter*.java               token → color mapping + factory\n  RefalColorSettingsPage.java                color settings UI\n  RefalBraceMatcher.java / RefalCommenter.java\n  RefalStructureViewFactory/Model/Element.java  structure view\n  RefalFoldingBuilder.java                     code folding\n  RefalCompletionContributor.java / RefalBuiltins.java   completion\n  psi/  parser, ParserDefinition, PSI nodes (RefalFile, RefalFunction, RefalBlock, RefalDirective)\n  RefalIcons.java\n  run/                                       run configuration (type, factory, settings, producer)\nsrc/main/resources/META-INF/plugin.xml\nsrc/main/resources/icons/refal.svg\nsrc/test/java/.../RefalScannerTest.java       pure scanner unit tests (JUnit 4)\nsrc/test/java/.../psi/RefalParsingTest.java   PSI parsing test (ParsingTestCase)\nsrc/test/testData/Hello.ref, Hello.txt        parsing-test input + expected PSI tree\nexamples/hello.ref, examples/showcase.ref     sample programs (see \"Verify the plugin works\")\n.github/workflows/build.yml, release.yml      CI: build/test/verify, and tagged releases\n```\n\n## Design notes \u0026 limitations\n\n**Scalability** (measured against the largest real Refal-5λ codebase — the\n[compiler's own repository](https://github.com/bmstu-iu9/refal-5-lambda), 901 `.ref`/`.refi`\nfiles, ~1.3 MB): the hand-written lexer tokenizes that entire corpus in ~17 ms on commodity\nhardware, and highlighting is per-file and incremental anyway. Find Usages and Rename are backed\nby the IDE word index (only candidate files are parsed). Cross-file Go to Declaration and\nGo to Symbol share one cached project-wide symbol map, rebuilt lazily after a PSI change rather\nthan rescanning the project per query. The plugin has no stub index — on a cold start or right\nafter an edit, the first cross-file navigation rebuilds the map by walking project Refal files\nonce; instant at these scales, but a stub-based index would be the next step for codebases of\nmany thousands of files. The inline compiler check (`rlc --grammar-check`) is per-file and took\n0.25 s on the project's largest file (107 KB); it does not process `$INCLUDE`, so multi-file\nprojects get no spurious include errors from it (verified against the real compiler).\n\n- Parsing is intentionally **lenient**: it never reports syntax errors, so valid code is never\n  shown as red. Function bodies are modelled as sentences (`pattern = result ;`) with parenthesized\n  groups, nested activations (`\u003c…\u003e`/`[…]`), and nested blocks; conditions and where-clauses are\n  tolerated rather than fully structured.\n- The lexer is mostly **stateless**; only string literals carry state (so escapes can be split out).\n- Inline `rlc` diagnostics: the editor text is compiled with `rlc` in an isolated temp directory\n  (so the project tree is untouched and unsaved edits are checked), and diagnostics — emitted as\n  `file:line:col: ERROR: message`, a format verified against the current `rlc` — are shown inline.\n  Because the check is isolated, files that `$INCLUDE` siblings may show spurious errors. If `rlc`\n  isn't found, nothing is shown. The invocation and parsing live in `RefalExternalAnnotator` and\n  `RefalDiagnosticParser`.\n  A newline always resets the state, so incremental re-highlighting stays cheap and correct.\n- **Function definition vs call** is a lexer-level heuristic (preceding `\u003c`/`[` ⇒ call, following\n  `{` ⇒ definition), not a full parser; unusual layouts may be mis-tagged but still get a sensible\n  color.\n- The **`%% … %%`** block is one highlighted region; it does not run a real C++ highlighter inside\n  (IDEA Community has no C++ support to delegate to).\n- The line-comment prefix `*` is only a comment in column 0. IntelliJ places line comments at\n  column 0 by default, so *Comment with Line Comment* matches Refal's rule.\n- The run configuration's compile-and-run uses simple shell chaining with basic path quoting; for\n  exotic paths/arguments, run compile and execution as separate configurations.\n\n## Tests \u0026 CI\n\n- `./gradlew test` runs the unit tests: fast, IntelliJ-free tests for the scanner\n  (`RefalScannerTest`) plus a `ParsingTestCase` (`RefalParsingTest`) that checks the produced PSI\n  tree against `src/test/testData/Hello.txt`.\n- `./gradlew verifyPlugin` runs the JetBrains Plugin Verifier to check binary compatibility and\n  plugin-descriptor validity. It targets the supported floor (2024.3, `sinceBuild`) **plus the\n  currently-recommended releases** (`recommended()` — the latest patches of recent majors): since\n  the plugin leaves `untilBuild` open and so claims forward compatibility, this is what actually\n  exercises that claim against newer IDEs. The recommended set is downloaded at verification time,\n  so it needs network and runs in CI rather than offline.\n- GitHub Actions (`.github/workflows/build.yml`) runs `check buildPlugin` and the verifier on every\n  push and pull request and uploads the built zip; `release.yml` builds the plugin and attaches the\n  zip to a GitHub Release when you push a `vX.Y.Z` tag.\n\n## Changing the target IDE\n\nEdit `build.gradle.kts`: `intellijIdeaCommunity(\"2024.3\")` (or `intellijIdeaUltimate(\"…\")`) and the\n`sinceBuild` / `untilBuild` under `pluginConfiguration { ideaVersion { … } }`.\n\n## Credits \u0026 license\n\nToken rules were informed by the Refal-5λ language and the community VS Code extension\n[GDVFox/vscode-refal-5-lambda](https://github.com/GDVFox/vscode-refal-5-lambda); the compiler is\n[bmstu-iu9/refal-5-lambda](https://github.com/bmstu-iu9/refal-5-lambda). A separate IDEA plugin also\nexists — [bmstu-iu9/RefalFiveLambdaPlugin](https://github.com/bmstu-iu9/RefalFiveLambdaPlugin), a 2020\nstudent coursework (BMSTU, dept. iu9) by Daria Tereshkina and Alexander Konovalov that builds its\nlexer and parser with JFlex and Grammar-Kit. This project is an independent implementation, and its\n**instant, compiler-free error highlighting** (*Unresolved function* / *Unresolved variable*) is\ninspired by that coursework — re-implemented here on this plugin's own grammar rather than copied.\nAll Java here was written from scratch for the IntelliJ Platform. Use and modify it freely; if you\npublish it, add your own license and plugin id.\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Falexeyev%2Frefalcon","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Falexeyev%2Frefalcon","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Falexeyev%2Frefalcon/lists"}