Compare commits
14
Commits
827df9c8cd
...
1.2.0
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
75723adbbc | ||
|
|
b7fe04d65f | ||
|
|
ec28b219f3 | ||
|
|
6fa57c8197 | ||
|
|
2d2a74656c | ||
|
|
80933c287d | ||
|
|
017111827d | ||
|
|
d2632cb99e | ||
|
|
474293cfe3 | ||
|
|
9924d02cb4 | ||
|
|
1efa96a990 | ||
|
|
f6deabaa38 | ||
|
|
8f04b25fcb | ||
|
|
6b957ae6a3 |
No files matched your search
@@ -0,0 +1,11 @@
|
||||
# Lyng Project Guidelines
|
||||
|
||||
This project uses the Lyng scripting language for multiplatform scripting.
|
||||
|
||||
## Coding in Lyng
|
||||
When writing, refactoring, or analyzing Lyng code:
|
||||
- **Reference**: Always use `LYNG_AI_SPEC.md` in the project root as the primary source of truth for syntax and idioms.
|
||||
- **File Extensions**: Use `.lyng` for all script files.
|
||||
- **Implicit Coroutines**: Remember that all Lyng functions are implicitly coroutines; do not look for `async/await`.
|
||||
- **Everything is an Expression**: Leverage the fact that blocks, if-statements, and loops return values.
|
||||
- **Maps vs Blocks**: Be careful: `{}` is a block/lambda, use `Map()` for an empty map.
|
||||
@@ -21,6 +21,12 @@
|
||||
- MI Satisfaction: Abstract requirements are automatically satisfied by matching concrete members found later in the C3 MRO chain without requiring explicit proxy methods.
|
||||
- Integration: Updated highlighters (lynglib, lyngweb, IDEA plugin), IDEA completion, and Grazie grammar checking.
|
||||
- Documentation: Updated `docs/OOP.md` with sections on "Abstract Classes and Members", "Interfaces", and "Overriding and Virtual Dispatch".
|
||||
- IDEA plugin: Improved natural language support and spellchecking
|
||||
- Disabled the limited built-in English and Technical dictionaries.
|
||||
- Enforced usage of the platform's standard Natural Languages (Grazie) and Spellchecker components.
|
||||
- Integrated `SpellCheckerManager` for word suggestions and validation, respecting users' personal and project dictionaries.
|
||||
- Added project-specific "learned words" support via `Lyng Formatter` settings and quick-fixes.
|
||||
- Enhanced fallback spellchecker for technical terms and Lyng-specific vocabulary.
|
||||
|
||||
- Language: Class properties with accessors
|
||||
- Support for `val` (read-only) and `var` (read-write) properties in classes.
|
||||
|
||||
+105
@@ -0,0 +1,105 @@
|
||||
# Lyng Language AI Specification (V1.3)
|
||||
|
||||
High-density specification for LLMs. Reference this for all Lyng code generation.
|
||||
|
||||
## 1. Core Philosophy & Syntax
|
||||
- **Everything is an Expression**: Blocks, `if`, `when`, `for`, `while`, `do-while` return their last expression (or `void`).
|
||||
- **Loops with `else`**: `for`, `while`, and `do-while` support an optional `else` block.
|
||||
- `else` executes **only if** the loop finishes normally (without a `break`).
|
||||
- `break <value>` exits the loop and sets its return value.
|
||||
- Loop Return Value:
|
||||
1. Value from `break <value>`.
|
||||
2. Result of `else` block (if loop finished normally and `else` exists).
|
||||
3. Result of the last iteration (if loop finished normally and no `else`).
|
||||
4. `void` (if loop body never executed and no `else`).
|
||||
- **Implicit Coroutines**: All functions are coroutines. No `async/await`. Use `launch { ... }` (returns `Deferred`) or `flow { ... }`.
|
||||
- **Variables**: `val` (read-only), `var` (mutable). Supports late-init `val` in classes (must be assigned in `init` or body).
|
||||
- **Null Safety**: `?` (nullable type), `?.` (safe access), `?( )` (safe invoke), `?{ }` (safe block invoke), `?[ ]` (safe index), `?:` or `??` (elvis), `?=` (assign-if-null).
|
||||
- **Equality**: `==` (equals), `!=` (not equals), `===` (ref identity), `!==` (ref not identity).
|
||||
- **Comparison**: `<`, `>`, `<=`, `>=`, `<=>` (shuttle/spaceship, returns -1, 0, 1).
|
||||
- **Destructuring**: `val [a, b, rest...] = list`. Supports nested `[a, [b, c]]` and splats.
|
||||
|
||||
## 2. Object-Oriented Programming (OOP)
|
||||
- **Multiple Inheritance**: Supported with **C3 MRO** (Python-style). Diamond-safe.
|
||||
- **Header Arguments**: `class Foo(a, b) : Base(a)` defines fields `a`, `b` and passes `a` to `Base`.
|
||||
- **Members**: `fun name(args) { ... }`, `val`, `var`, `static val`, `static fun`.
|
||||
- **Properties (Get/Set)**: Pure accessors, no auto-backing fields.
|
||||
```lyng
|
||||
var age
|
||||
get() = _age
|
||||
private set(v) { if(v >= 0) _age = v }
|
||||
// Laconic syntax:
|
||||
val area get = π * r * r
|
||||
```
|
||||
- **Mandatory `override`**: Required for all members existing in the ancestor chain.
|
||||
- **Visibility**: `public` (default), `protected` (subclasses), `private` (this class instance only). `private set` / `protected set` allowed on properties.
|
||||
- **Disambiguation**: `this@Base.member()` or `(obj as Base).member()`. `as` returns a qualified view.
|
||||
- **Abstract/Interface**: `interface` is a synonym for `abstract class`. Both support state and constructors.
|
||||
- **Extensions**: `fun Class.ext()` or `val Class.ext get = ...`. Scope-isolated.
|
||||
|
||||
## 3. Delegation (`by`)
|
||||
Unified model for `val`, `var`, and `fun`.
|
||||
```lyng
|
||||
val x by MyDelegate()
|
||||
var y by Map() // Uses "y" as key in map
|
||||
fn f(a, b) by RemoteProxy() // Calls Proxy.invoke(thisRef, "f", a, b)
|
||||
```
|
||||
Delegate Methods:
|
||||
- `getValue(thisRef, name)`: for `val`/`var`.
|
||||
- `setValue(thisRef, name, val)`: for `var`.
|
||||
- `invoke(thisRef, name, args...)`: for `fn` (called if `getValue` is absent).
|
||||
- `bind(name, access, thisRef)`: optional hook called at declaration/binding time. `access` is `DelegateAccess.Val`, `Var`, or `Callable`.
|
||||
|
||||
## 4. Standard Library & Functional Built-ins
|
||||
- **Scope Functions**:
|
||||
- `obj.let { it... }`: result of block. `it` is `obj`.
|
||||
- `obj.apply { this... }`: returns `obj`. `this` is `obj`.
|
||||
- `obj.also { it... }`: returns `obj`. `it` is `obj`.
|
||||
- `obj.run { this... }`: result of block. `this` is `obj`.
|
||||
- `with(obj, { ... })`: result of block. `this` is `obj`.
|
||||
- **Functional**: `forEach`, `map`, `filter`, `any`, `all`, `sum`, `count`, `sortedBy`, `flatten`, `flatMap`, `associateBy`.
|
||||
- **Lazy**: `val x = cached { expensive() }` (call as `x()`) or `val x by lazy { ... }`.
|
||||
- **Collections**: `List` ( `[a, b]` ), `Map` ( `Map(k => v)` ), `Set` ( `Set(a, b)` ). `MapEntry` ( `k => v` ).
|
||||
|
||||
## 5. Patterns & Shorthands
|
||||
- **Map Literals**: `{ key: value, identifier: }` (identifier shorthand `x:` is `x: x`). Empty map is `Map()`.
|
||||
- **Named Arguments**: `fun(y: 10, x: 5)`. Shorthand: `Point(x:, y:)`.
|
||||
- **Varargs & Splats**: `fun f(args...)`, `f(...otherList)`.
|
||||
- **Labels**: `loop@ for(x in list) { if(x == 0) break@loop }`.
|
||||
- **Dynamic**: `val d = dynamic { get { name -> ... } }` allows `d.anyName`.
|
||||
|
||||
## 6. Operators & Methods to Overload
|
||||
| Op | Method | Op | Method |
|
||||
| :--- | :--- | :--- | :--- |
|
||||
| `+` | `plus` | `==` | `equals` |
|
||||
| `-` | `minus` | `<=>` | `compareTo` |
|
||||
| `*` | `mul` | `[]` | `getAt` / `putAt` |
|
||||
| `/` | `div` | `!` | `logicalNot` |
|
||||
| `%` | `mod` | `-` | `negate` (unary) |
|
||||
| `=~` | `operatorMatch` | `+=` | `plusAssign` |
|
||||
|
||||
## 7. Common Snippets
|
||||
```lyng
|
||||
// Multiple Inheritance and Properties
|
||||
class Warrior(id, hp) : Character(id), HealthPool(hp) {
|
||||
override fun toString() = "Warrior #%s (%s HP)"(id, hp)
|
||||
}
|
||||
|
||||
// Map entry and merging
|
||||
val m = Map("a" => 1) + ("b" => 2)
|
||||
m += "c" => 3
|
||||
|
||||
// Destructuring with splat
|
||||
val [first, middle..., last] = [1, 2, 3, 4, 5]
|
||||
|
||||
// Safe Navigation and Elvis
|
||||
val companyName = person?.job?.company?.name ?? "Freelancer"
|
||||
```
|
||||
|
||||
## 8. Standard Library Discovery
|
||||
To collect data on the standard library and available APIs, AI should inspect:
|
||||
- **Global Symbols**: `lynglib/src/commonMain/kotlin/net/sergeych/lyng/Script.kt` (root functions like `println`, `sqrt`, `assert`).
|
||||
- **Core Type Members**: `lynglib/src/commonMain/kotlin/net/sergeych/lyng/obj/*.kt` (e.g., `ObjList.kt`, `ObjString.kt`, `ObjMap.kt`) for methods on built-in types.
|
||||
- **Lyng-side Extensions**: `lynglib/stdlib/lyng/root.lyng` for high-level functional APIs (e.g., `map`, `filter`, `any`, `lazy`).
|
||||
- **I/O & Processes**: `lyngio/src/commonMain/kotlin/net/sergeych/lyng/io/` for `fs` and `process` modules.
|
||||
- **Documentation**: `docs/*.md` (e.g., `tutorial.md`, `lyngio.md`) for high-level usage and module overviews.
|
||||
@@ -140,6 +140,12 @@ Tips:
|
||||
- After a dot, globals are intentionally suppressed (e.g., `lines().Path` is not valid), only the receiver’s members are suggested.
|
||||
- If completion seems sparse, make sure related modules are imported (e.g., `import lyng.io.fs` so that `Path` and its methods are known).
|
||||
|
||||
## AI Assistant Support
|
||||
|
||||
To help AI assistants (like Cursor, Windsurf, or GitHub Copilot) understand Lyng with minimal effort, we provide a high-density language specification:
|
||||
|
||||
- **[LYNG_AI_SPEC.md](LYNG_AI_SPEC.md)**: A concise guide for AI models to learn Lyng syntax, idioms, and core philosophy. We recommend pointing your AI tool to this file or including it in your project's custom instructions.
|
||||
|
||||
## Why?
|
||||
|
||||
Designed to add scripting to kotlin multiplatform application in easy and efficient way. This is attempt to achieve what Lua is for C/++.
|
||||
|
||||
Executable
+26
@@ -0,0 +1,26 @@
|
||||
#!/bin/sh
|
||||
|
||||
#
|
||||
# Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 (the "License");
|
||||
# you may not use this file except in compliance with the License.
|
||||
# You may obtain a copy of the License at
|
||||
#
|
||||
# http://www.apache.org/licenses/LICENSE-2.0
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
#
|
||||
#
|
||||
|
||||
set -e
|
||||
|
||||
echo
|
||||
echo "Creating plugin"
|
||||
echo
|
||||
./gradlew buildInstallablePlugin
|
||||
deploy_site -u
|
||||
+38
-26
@@ -1,7 +1,7 @@
|
||||
#!/bin/bash
|
||||
|
||||
#
|
||||
# Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
# Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 (the "License");
|
||||
# you may not use this file except in compliance with the License.
|
||||
@@ -17,6 +17,14 @@
|
||||
#
|
||||
#
|
||||
|
||||
upload_only=false
|
||||
for arg in "$@"; do
|
||||
if [[ "$arg" == "-u" || "$arg" == "--upload-only" ]]; then
|
||||
upload_only=true
|
||||
break
|
||||
fi
|
||||
done
|
||||
|
||||
function checkState() {
|
||||
if [[ $? != 0 ]]; then
|
||||
echo
|
||||
@@ -24,9 +32,10 @@ function checkState() {
|
||||
echo
|
||||
exit 100
|
||||
fi
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
# Update docs/idea_plugin.md to point to the latest built IDEA plugin zip
|
||||
# from ./distributables before building the site. The change is temporary and
|
||||
# the original file is restored right after the build.
|
||||
@@ -107,28 +116,28 @@ function refreshTextmateZip() {
|
||||
(cd editors && zip -rq ../distributables/lyng-textmate.zip .)
|
||||
}
|
||||
|
||||
# Update the IDEA plugin download link in docs (temporarily), then build, then restore the doc
|
||||
refreshTextmateZip
|
||||
updateIdeaPluginDownloadLink || echo "WARN: proceeding without updating IDEA plugin download link"
|
||||
|
||||
./gradlew site:jsBrowserDistribution
|
||||
BUILD_RC=$?
|
||||
if [[ "$upload_only" == false ]]; then
|
||||
# Update the IDEA plugin download link in docs (temporarily), then build, then restore the doc
|
||||
refreshTextmateZip
|
||||
updateIdeaPluginDownloadLink || echo "WARN: proceeding without updating IDEA plugin download link"
|
||||
|
||||
# Always restore original doc if backup exists
|
||||
if [[ -f "$DOC_IDEA_PLUGIN_BACKUP" ]]; then
|
||||
mv -f "$DOC_IDEA_PLUGIN_BACKUP" "$DOC_IDEA_PLUGIN"
|
||||
./gradlew site:jsBrowserDistribution
|
||||
BUILD_RC=$?
|
||||
|
||||
# Always restore original doc if backup exists
|
||||
if [[ -f "$DOC_IDEA_PLUGIN_BACKUP" ]]; then
|
||||
mv -f "$DOC_IDEA_PLUGIN_BACKUP" "$DOC_IDEA_PLUGIN"
|
||||
fi
|
||||
|
||||
if [[ $BUILD_RC -ne 0 ]]; then
|
||||
echo
|
||||
echo -- build failed. deploy aborted.
|
||||
echo
|
||||
exit 100
|
||||
fi
|
||||
fi
|
||||
|
||||
if [[ $BUILD_RC -ne 0 ]]; then
|
||||
echo
|
||||
echo -- build failed. deploy aborted.
|
||||
echo
|
||||
exit 100
|
||||
fi
|
||||
|
||||
|
||||
#exit 0
|
||||
|
||||
# Prepare working dir
|
||||
ssh -p ${SSH_PORT} ${SSH_HOST} "
|
||||
cd ${ROOT}
|
||||
@@ -143,12 +152,15 @@ ssh -p ${SSH_PORT} ${SSH_HOST} "
|
||||
fi
|
||||
";
|
||||
|
||||
# sync files
|
||||
SRC=./site/build/dist/js/productionExecutable
|
||||
rsync -e "ssh -p ${SSH_PORT}" -avz -r -d --delete ${SRC}/* ${SSH_HOST}:${ROOT}/build/dist
|
||||
checkState
|
||||
#rsync -e "ssh -p ${SSH_PORT}" -avz ./static/* ${SSH_HOST}:${ROOT}/build/dist
|
||||
#checkState
|
||||
if [[ "$upload_only" == false ]]; then
|
||||
# sync files
|
||||
SRC=./site/build/dist/js/productionExecutable
|
||||
rsync -e "ssh -p ${SSH_PORT}" -avz -r -d --delete ${SRC}/* ${SSH_HOST}:${ROOT}/build/dist
|
||||
checkState
|
||||
#rsync -e "ssh -p ${SSH_PORT}" -avz ./static/* ${SSH_HOST}:${ROOT}/build/dist
|
||||
#checkState
|
||||
fi
|
||||
|
||||
rsync -e "ssh -p ${SSH_PORT}" -avz -r -d --delete distributables/* ${SSH_HOST}:${ROOT}/build/dist/distributables
|
||||
checkState
|
||||
|
||||
|
||||
+1
-1
@@ -33,7 +33,7 @@ PerfProfiles.restore(snap) // restore previous flags
|
||||
- `ARG_BUILDER` — Efficient argument building: small‑arity no‑alloc and pooled builder on JVM (ON JVM default).
|
||||
- `ARG_SMALL_ARITY_12` — Extends small‑arity no‑alloc call paths from 0–8 to 0–12 arguments (JVM‑first exploration; OFF by default). Use for codebases with many 9–12 arg calls; A/B before enabling.
|
||||
- `SKIP_ARGS_ON_NULL_RECEIVER` — Early return on optional‑null receivers before building args (semantics‑compatible). A/B only.
|
||||
- `SCOPE_POOL` — Scope frame pooling for calls (JVM, per‑thread ThreadLocal pool). ON by default on JVM; togglable at runtime.
|
||||
- `SCOPE_POOL` — Scope frame pooling for calls (per‑thread ThreadLocal pool on JVM/Android/Native; global deque on JS/Wasm). ON by default on all platforms; togglable at runtime.
|
||||
- `FIELD_PIC` — 2‑entry polymorphic inline cache for field reads/writes keyed by `(classId, layoutVersion)` (ON JVM default).
|
||||
- `METHOD_PIC` — 2‑entry PIC for instance method calls keyed by `(classId, layoutVersion)` (ON JVM default).
|
||||
- `FIELD_PIC_SIZE_4` — Increases Field PIC size from 2 to 4 entries (JVM-first tuning; OFF by default). Use for sites with >2 receiver shapes.
|
||||
|
||||
+8
-2
@@ -1252,7 +1252,7 @@ The same with `--`:
|
||||
sum
|
||||
>>> 5050
|
||||
|
||||
There are self-assigning version for operators too:
|
||||
There is a self-assigning version for operators too:
|
||||
|
||||
var count = 100
|
||||
var sum = 0
|
||||
@@ -1471,7 +1471,13 @@ Part match:
|
||||
assert( "foo" == $~.value )
|
||||
>>> void
|
||||
|
||||
Typical set of String functions includes:
|
||||
Repeating the fragment:
|
||||
|
||||
assertEquals("hellohello", "hello"*2)
|
||||
assertEquals("", "hello"*0)
|
||||
>>> void
|
||||
|
||||
A typical set of String functions includes:
|
||||
|
||||
| fun/prop | description / notes |
|
||||
|----------------------|------------------------------------------------------------|
|
||||
|
||||
@@ -17,7 +17,7 @@
|
||||
|
||||
plugins {
|
||||
kotlin("jvm")
|
||||
id("org.jetbrains.intellij") version "1.17.3"
|
||||
id("org.jetbrains.intellij") version "1.17.4"
|
||||
}
|
||||
|
||||
group = "net.sergeych.lyng"
|
||||
@@ -52,7 +52,7 @@ dependencies {
|
||||
intellij {
|
||||
type.set("IC")
|
||||
// Build against a modern baseline. Install range is controlled by since/until below.
|
||||
version.set("2024.3.1")
|
||||
version.set("2024.1.6")
|
||||
// We manage <idea-version> ourselves in plugin.xml to keep it open-ended (no upper cap)
|
||||
updateSinceUntilBuild.set(false)
|
||||
// Include only available bundled plugins for this IDE build
|
||||
|
||||
@@ -0,0 +1,144 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyng.idea.actions
|
||||
|
||||
import com.intellij.execution.filters.TextConsoleBuilderFactory
|
||||
import com.intellij.execution.ui.ConsoleView
|
||||
import com.intellij.execution.ui.ConsoleViewContentType
|
||||
import com.intellij.openapi.actionSystem.AnAction
|
||||
import com.intellij.openapi.actionSystem.AnActionEvent
|
||||
import com.intellij.openapi.actionSystem.CommonDataKeys
|
||||
import com.intellij.openapi.project.Project
|
||||
import com.intellij.openapi.wm.ToolWindow
|
||||
import com.intellij.openapi.wm.ToolWindowAnchor
|
||||
import com.intellij.openapi.wm.ToolWindowId
|
||||
import com.intellij.openapi.wm.ToolWindowManager
|
||||
import com.intellij.psi.PsiFile
|
||||
import com.intellij.psi.PsiManager
|
||||
import com.intellij.ui.content.ContentFactory
|
||||
import kotlinx.coroutines.CoroutineScope
|
||||
import kotlinx.coroutines.Dispatchers
|
||||
import kotlinx.coroutines.SupervisorJob
|
||||
import kotlinx.coroutines.launch
|
||||
import net.sergeych.lyng.ExecutionError
|
||||
import net.sergeych.lyng.Script
|
||||
import net.sergeych.lyng.Source
|
||||
import net.sergeych.lyng.idea.LyngIcons
|
||||
import net.sergeych.lyng.obj.ObjVoid
|
||||
import net.sergeych.lyng.obj.getLyngExceptionMessageWithStackTrace
|
||||
|
||||
class RunLyngScriptAction : AnAction(LyngIcons.FILE) {
|
||||
private val scope = CoroutineScope(Dispatchers.Default + SupervisorJob())
|
||||
|
||||
private fun getPsiFile(e: AnActionEvent): PsiFile? {
|
||||
val project = e.project ?: return null
|
||||
return e.getData(CommonDataKeys.PSI_FILE) ?: run {
|
||||
val vf = e.getData(CommonDataKeys.VIRTUAL_FILE)
|
||||
if (vf != null) PsiManager.getInstance(project).findFile(vf) else null
|
||||
}
|
||||
}
|
||||
|
||||
override fun update(e: AnActionEvent) {
|
||||
val psiFile = getPsiFile(e)
|
||||
val isLyng = psiFile?.name?.endsWith(".lyng") == true
|
||||
e.presentation.isEnabledAndVisible = isLyng
|
||||
if (isLyng) {
|
||||
e.presentation.text = "Run '${psiFile.name}'"
|
||||
} else {
|
||||
e.presentation.text = "Run Lyng Script"
|
||||
}
|
||||
}
|
||||
|
||||
override fun actionPerformed(e: AnActionEvent) {
|
||||
val project = e.project ?: return
|
||||
val psiFile = getPsiFile(e) ?: return
|
||||
val text = psiFile.text
|
||||
val fileName = psiFile.name
|
||||
|
||||
val (console, toolWindow) = getConsoleAndToolWindow(project)
|
||||
console.clear()
|
||||
|
||||
toolWindow.show {
|
||||
scope.launch {
|
||||
try {
|
||||
val lyngScope = Script.newScope()
|
||||
lyngScope.addFn("print") {
|
||||
val sb = StringBuilder()
|
||||
for ((i, arg) in args.list.withIndex()) {
|
||||
if (i > 0) sb.append(" ")
|
||||
sb.append(arg.toString(this).value)
|
||||
}
|
||||
console.print(sb.toString(), ConsoleViewContentType.NORMAL_OUTPUT)
|
||||
ObjVoid
|
||||
}
|
||||
lyngScope.addFn("println") {
|
||||
val sb = StringBuilder()
|
||||
for ((i, arg) in args.list.withIndex()) {
|
||||
if (i > 0) sb.append(" ")
|
||||
sb.append(arg.toString(this).value)
|
||||
}
|
||||
console.print(sb.toString() + "\n", ConsoleViewContentType.NORMAL_OUTPUT)
|
||||
ObjVoid
|
||||
}
|
||||
|
||||
console.print("--- Running $fileName ---\n", ConsoleViewContentType.SYSTEM_OUTPUT)
|
||||
val result = lyngScope.eval(Source(fileName, text))
|
||||
console.print("\n--- Finished with result: ${result.inspect(lyngScope)} ---\n", ConsoleViewContentType.SYSTEM_OUTPUT)
|
||||
} catch (t: Throwable) {
|
||||
console.print("\n--- Error ---\n", ConsoleViewContentType.ERROR_OUTPUT)
|
||||
if( t is ExecutionError ) {
|
||||
val m = t.errorObject.getLyngExceptionMessageWithStackTrace()
|
||||
console.print(m, ConsoleViewContentType.ERROR_OUTPUT)
|
||||
}
|
||||
else
|
||||
console.print(t.message ?: t.toString(), ConsoleViewContentType.ERROR_OUTPUT)
|
||||
console.print("\n", ConsoleViewContentType.ERROR_OUTPUT)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun getConsoleAndToolWindow(project: Project): Pair<ConsoleView, ToolWindow> {
|
||||
val toolWindowManager = ToolWindowManager.getInstance(project)
|
||||
var toolWindow = toolWindowManager.getToolWindow(ToolWindowId.RUN)
|
||||
if (toolWindow == null) {
|
||||
toolWindow = toolWindowManager.getToolWindow(ToolWindowId.MESSAGES_WINDOW)
|
||||
}
|
||||
if (toolWindow == null) {
|
||||
toolWindow = toolWindowManager.getToolWindow("Lyng")
|
||||
}
|
||||
val actualToolWindow = toolWindow ?: run {
|
||||
@Suppress("DEPRECATION")
|
||||
toolWindowManager.registerToolWindow("Lyng", true, ToolWindowAnchor.BOTTOM)
|
||||
}
|
||||
|
||||
val contentManager = actualToolWindow.contentManager
|
||||
val existingContent = contentManager.findContent("Lyng Run")
|
||||
if (existingContent != null) {
|
||||
val console = existingContent.component as ConsoleView
|
||||
contentManager.setSelectedContent(existingContent)
|
||||
return console to actualToolWindow
|
||||
}
|
||||
|
||||
val console = TextConsoleBuilderFactory.getInstance().createBuilder(project).console
|
||||
val content = ContentFactory.getInstance().createContent(console.component, "Lyng Run", false)
|
||||
contentManager.addContent(content)
|
||||
contentManager.setSelectedContent(content)
|
||||
return console to actualToolWindow
|
||||
}
|
||||
}
|
||||
+44
-73
@@ -44,10 +44,7 @@ class LyngExternalAnnotator : ExternalAnnotator<LyngExternalAnnotator.Input, Lyn
|
||||
|
||||
data class Span(val start: Int, val end: Int, val key: com.intellij.openapi.editor.colors.TextAttributesKey)
|
||||
data class Error(val start: Int, val end: Int, val message: String)
|
||||
data class Result(val modStamp: Long, val spans: List<Span>, val error: Error? = null,
|
||||
val spellIdentifiers: List<IntRange> = emptyList(),
|
||||
val spellComments: List<IntRange> = emptyList(),
|
||||
val spellStrings: List<IntRange> = emptyList())
|
||||
data class Result(val modStamp: Long, val spans: List<Span>, val error: Error? = null)
|
||||
|
||||
override fun collectInformation(file: PsiFile): Input? {
|
||||
val doc: Document = file.viewProvider.document ?: return null
|
||||
@@ -62,6 +59,7 @@ class LyngExternalAnnotator : ExternalAnnotator<LyngExternalAnnotator.Input, Lyn
|
||||
if (collectedInfo == null) return null
|
||||
ProgressManager.checkCanceled()
|
||||
val text = collectedInfo.text
|
||||
val tokens = try { SimpleLyngHighlighter().highlight(text) } catch (_: Throwable) { emptyList() }
|
||||
|
||||
// Use LyngAstManager to get the (potentially merged) Mini-AST
|
||||
val mini = LyngAstManager.getMiniAst(collectedInfo.file)
|
||||
@@ -117,9 +115,18 @@ class LyngExternalAnnotator : ExternalAnnotator<LyngExternalAnnotator.Input, Lyn
|
||||
}
|
||||
|
||||
// Parameters
|
||||
mini.declarations.filterIsInstance<MiniFunDecl>().forEach { fn ->
|
||||
if (fn.nameStart.source != source) return@forEach
|
||||
fn.params.forEach { p -> putName(p.nameStart, p.name, LyngHighlighterColors.PARAMETER) }
|
||||
fun addParams(params: List<MiniParam>) {
|
||||
params.forEach { p ->
|
||||
if (p.nameStart.source == source)
|
||||
putName(p.nameStart, p.name, LyngHighlighterColors.PARAMETER)
|
||||
}
|
||||
}
|
||||
mini.declarations.forEach { d ->
|
||||
when (d) {
|
||||
is MiniFunDecl -> addParams(d.params)
|
||||
is MiniClassDecl -> d.members.filterIsInstance<MiniMemberFunDecl>().forEach { addParams(it.params) }
|
||||
else -> {}
|
||||
}
|
||||
}
|
||||
|
||||
// Type name segments (including generics base & args)
|
||||
@@ -146,8 +153,8 @@ class LyngExternalAnnotator : ExternalAnnotator<LyngExternalAnnotator.Input, Lyn
|
||||
null -> {}
|
||||
}
|
||||
}
|
||||
mini.declarations.forEach { d ->
|
||||
if (d.nameStart.source != source) return@forEach
|
||||
fun addDeclTypeSegments(d: MiniDecl) {
|
||||
if (d.nameStart.source != source) return
|
||||
when (d) {
|
||||
is MiniFunDecl -> {
|
||||
addTypeSegments(d.returnType)
|
||||
@@ -161,10 +168,23 @@ class LyngExternalAnnotator : ExternalAnnotator<LyngExternalAnnotator.Input, Lyn
|
||||
is MiniClassDecl -> {
|
||||
d.ctorFields.forEach { addTypeSegments(it.type) }
|
||||
d.classFields.forEach { addTypeSegments(it.type) }
|
||||
for (m in d.members) {
|
||||
when (m) {
|
||||
is MiniMemberFunDecl -> {
|
||||
addTypeSegments(m.returnType)
|
||||
m.params.forEach { addTypeSegments(it.type) }
|
||||
}
|
||||
is MiniMemberValDecl -> {
|
||||
addTypeSegments(m.type)
|
||||
}
|
||||
else -> {}
|
||||
}
|
||||
}
|
||||
}
|
||||
is MiniEnumDecl -> {}
|
||||
}
|
||||
}
|
||||
mini.declarations.forEach { d -> addDeclTypeSegments(d) }
|
||||
|
||||
ProgressManager.checkCanceled()
|
||||
|
||||
@@ -202,8 +222,6 @@ class LyngExternalAnnotator : ExternalAnnotator<LyngExternalAnnotator.Input, Lyn
|
||||
// Heuristics on top of binder: function call-sites and simple name-based roles
|
||||
ProgressManager.checkCanceled()
|
||||
|
||||
val tokens = try { SimpleLyngHighlighter().highlight(text) } catch (_: Throwable) { emptyList() }
|
||||
|
||||
// Build simple name -> role map for top-level vals/vars and parameters
|
||||
val nameRole = HashMap<String, com.intellij.openapi.editor.colors.TextAttributesKey>(8)
|
||||
mini.declarations.forEach { d ->
|
||||
@@ -212,6 +230,13 @@ class LyngExternalAnnotator : ExternalAnnotator<LyngExternalAnnotator.Input, Lyn
|
||||
if (d.mutable) LyngHighlighterColors.VARIABLE else LyngHighlighterColors.VALUE
|
||||
|
||||
is MiniFunDecl -> d.params.forEach { p -> nameRole[p.name] = LyngHighlighterColors.PARAMETER }
|
||||
is MiniClassDecl -> {
|
||||
d.members.forEach { m ->
|
||||
if (m is MiniMemberFunDecl) {
|
||||
m.params.forEach { p -> nameRole[p.name] = LyngHighlighterColors.PARAMETER }
|
||||
}
|
||||
}
|
||||
}
|
||||
else -> {}
|
||||
}
|
||||
}
|
||||
@@ -251,7 +276,6 @@ class LyngExternalAnnotator : ExternalAnnotator<LyngExternalAnnotator.Input, Lyn
|
||||
|
||||
// Add annotation/label coloring using token highlighter
|
||||
run {
|
||||
val tokens = try { SimpleLyngHighlighter().highlight(text) } catch (_: Throwable) { emptyList() }
|
||||
tokens.forEach { s ->
|
||||
if (s.kind == HighlightKind.Label) {
|
||||
val start = s.range.start
|
||||
@@ -291,47 +315,20 @@ class LyngExternalAnnotator : ExternalAnnotator<LyngExternalAnnotator.Input, Lyn
|
||||
}
|
||||
}
|
||||
|
||||
// Map Enum constants from token highlighter to IDEA enum constant color
|
||||
run {
|
||||
val tokens = try { SimpleLyngHighlighter().highlight(text) } catch (_: Throwable) { emptyList() }
|
||||
tokens.forEach { s ->
|
||||
if (s.kind == HighlightKind.EnumConstant) {
|
||||
val start = s.range.start
|
||||
val end = s.range.endExclusive
|
||||
if (start in 0..end && end <= text.length && start < end) {
|
||||
putRange(start, end, LyngHighlighterColors.ENUM_CONSTANT)
|
||||
}
|
||||
tokens.forEach { s ->
|
||||
if (s.kind == HighlightKind.EnumConstant) {
|
||||
val start = s.range.start
|
||||
val end = s.range.endExclusive
|
||||
if (start in 0..end && end <= text.length && start < end) {
|
||||
putRange(start, end, LyngHighlighterColors.ENUM_CONSTANT)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Build spell index payload: identifiers from symbols + references; comments/strings from simple highlighter
|
||||
val idRanges = mutableSetOf<IntRange>()
|
||||
try {
|
||||
val binding = Binder.bind(text, mini)
|
||||
binding.symbols.forEach { sym ->
|
||||
val s = sym.declStart
|
||||
val e = sym.declEnd
|
||||
if (s in 0..e && e <= text.length && s < e) idRanges += (s until e)
|
||||
}
|
||||
binding.references.forEach { ref ->
|
||||
val s = ref.start
|
||||
val e = ref.end
|
||||
if (s in 0..e && e <= text.length && s < e) idRanges += (s until e)
|
||||
}
|
||||
} catch (_: Throwable) {
|
||||
// Best-effort; no identifiers if binder fails
|
||||
}
|
||||
val tokens = try { SimpleLyngHighlighter().highlight(text) } catch (_: Throwable) { emptyList() }
|
||||
val commentRanges = tokens.filter { it.kind == HighlightKind.Comment }.map { it.range.start until it.range.endExclusive }
|
||||
val stringRanges = tokens.filter { it.kind == HighlightKind.String }.map { it.range.start until it.range.endExclusive }
|
||||
|
||||
return Result(collectedInfo.modStamp, out, null,
|
||||
spellIdentifiers = idRanges.toList(),
|
||||
spellComments = commentRanges,
|
||||
spellStrings = stringRanges)
|
||||
return Result(collectedInfo.modStamp, out, null)
|
||||
}
|
||||
|
||||
|
||||
override fun apply(file: PsiFile, annotationResult: Result?, holder: AnnotationHolder) {
|
||||
if (annotationResult == null) return
|
||||
// Skip if cache is up-to-date
|
||||
@@ -342,32 +339,6 @@ class LyngExternalAnnotator : ExternalAnnotator<LyngExternalAnnotator.Input, Lyn
|
||||
|
||||
val doc = file.viewProvider.document
|
||||
|
||||
// Store spell index for spell/grammar engines to consume (suspend until ready)
|
||||
val ids = result.spellIdentifiers.map { TextRange(it.first, it.last + 1) }
|
||||
val coms = result.spellComments.map { TextRange(it.first, it.last + 1) }
|
||||
val strs = result.spellStrings.map { TextRange(it.first, it.last + 1) }
|
||||
net.sergeych.lyng.idea.spell.LyngSpellIndex.store(file,
|
||||
net.sergeych.lyng.idea.spell.LyngSpellIndex.Data(
|
||||
modStamp = result.modStamp,
|
||||
identifiers = ids,
|
||||
comments = coms,
|
||||
strings = strs
|
||||
)
|
||||
)
|
||||
|
||||
// Optional diagnostic overlay: visualize the ranges we will feed to spellcheckers
|
||||
val settings = net.sergeych.lyng.idea.settings.LyngFormatterSettings.getInstance(file.project)
|
||||
if (settings.debugShowSpellFeed) {
|
||||
fun paint(r: TextRange, label: String) {
|
||||
holder.newAnnotation(HighlightSeverity.WEAK_WARNING, "spell-feed: $label")
|
||||
.range(r)
|
||||
.create()
|
||||
}
|
||||
ids.forEach { paint(it, "id") }
|
||||
coms.forEach { paint(it, "comment") }
|
||||
if (settings.spellCheckStringLiterals) strs.forEach { paint(it, "string") }
|
||||
}
|
||||
|
||||
for (s in result.spans) {
|
||||
holder.newSilentAnnotation(HighlightSeverity.INFORMATION)
|
||||
.range(TextRange(s.start, s.end))
|
||||
|
||||
+38
-43
@@ -116,7 +116,7 @@ class LyngCompletionContributor : CompletionContributor() {
|
||||
if (memberDotPos != null && engineItems.isEmpty()) {
|
||||
if (DEBUG_COMPLETION) log.info("[LYNG_DEBUG] Fallback: engine returned 0 in member context; trying local inference")
|
||||
// Build imported modules from text (lenient) + stdlib; avoid heavy MiniAst here
|
||||
val fromText = extractImportsFromText(text)
|
||||
val fromText = DocLookupUtils.extractImportsFromText(text)
|
||||
val imported = LinkedHashSet<String>().apply {
|
||||
fromText.forEach { add(it) }
|
||||
add("lyng.stdlib")
|
||||
@@ -167,12 +167,16 @@ class LyngCompletionContributor : CompletionContributor() {
|
||||
.withIcon(AllIcons.Nodes.Field)
|
||||
.let { b -> if (!ci.typeText.isNullOrBlank()) b.withTypeText(ci.typeText, true) else b }
|
||||
}
|
||||
emit(builder)
|
||||
if (ci.priority != 0.0) {
|
||||
emit(PrioritizedLookupElement.withPriority(builder, ci.priority))
|
||||
} else {
|
||||
emit(builder)
|
||||
}
|
||||
}
|
||||
// In member context, ensure stdlib extension-like methods (e.g., String.re) are present
|
||||
if (memberDotPos != null) {
|
||||
val existing = engineItems.map { it.name }.toMutableSet()
|
||||
val fromText = extractImportsFromText(text)
|
||||
val fromText = DocLookupUtils.extractImportsFromText(text)
|
||||
val imported = LinkedHashSet<String>().apply {
|
||||
fromText.forEach { add(it) }
|
||||
add("lyng.stdlib")
|
||||
@@ -245,7 +249,7 @@ class LyngCompletionContributor : CompletionContributor() {
|
||||
// If in member context and engine items are suspiciously sparse, try to enrich via local inference + offerMembers
|
||||
if (memberDotPos != null && engineItems.size < 3) {
|
||||
if (DEBUG_COMPLETION) log.info("[LYNG_DEBUG] Engine produced only ${engineItems.size} items in member context — trying enrichment")
|
||||
val fromText = extractImportsFromText(text)
|
||||
val fromText = DocLookupUtils.extractImportsFromText(text)
|
||||
val imported = LinkedHashSet<String>().apply {
|
||||
fromText.forEach { add(it) }
|
||||
add("lyng.stdlib")
|
||||
@@ -401,18 +405,23 @@ class LyngCompletionContributor : CompletionContributor() {
|
||||
}
|
||||
supplementPreferredBases(className)
|
||||
|
||||
fun emitGroup(map: LinkedHashMap<String, MutableList<MiniMemberDecl>>) {
|
||||
fun emitGroup(map: LinkedHashMap<String, MutableList<MiniMemberDecl>>, groupPriority: Double) {
|
||||
val keys = map.keys.sortedBy { it.lowercase() }
|
||||
for (name in keys) {
|
||||
val list = map[name] ?: continue
|
||||
// Choose a representative for display:
|
||||
// 1) Prefer a method with a known return type
|
||||
// 2) Else any method
|
||||
// 3) Else the first variant
|
||||
// 1) Prefer a method with return type AND parameters
|
||||
// 2) Prefer a method with parameters
|
||||
// 3) Prefer a method with return type
|
||||
// 4) Else any method
|
||||
// 5) Else the first variant
|
||||
val rep =
|
||||
list.asSequence()
|
||||
.filterIsInstance<MiniMemberFunDecl>()
|
||||
.firstOrNull { it.returnType != null }
|
||||
list.asSequence().filterIsInstance<MiniMemberFunDecl>()
|
||||
.firstOrNull { it.returnType != null && it.params.isNotEmpty() }
|
||||
?: list.asSequence().filterIsInstance<MiniMemberFunDecl>()
|
||||
.firstOrNull { it.params.isNotEmpty() }
|
||||
?: list.asSequence().filterIsInstance<MiniMemberFunDecl>()
|
||||
.firstOrNull { it.returnType != null }
|
||||
?: list.firstOrNull { it is MiniMemberFunDecl }
|
||||
?: list.first()
|
||||
when (rep) {
|
||||
@@ -428,7 +437,11 @@ class LyngCompletionContributor : CompletionContributor() {
|
||||
.withTailText(tail, true)
|
||||
.withTypeText(ret, true)
|
||||
.withInsertHandler(ParenInsertHandler)
|
||||
emit(builder)
|
||||
if (groupPriority != 0.0) {
|
||||
emit(PrioritizedLookupElement.withPriority(builder, groupPriority))
|
||||
} else {
|
||||
emit(builder)
|
||||
}
|
||||
}
|
||||
is MiniMemberValDecl -> {
|
||||
val icon = if (rep.mutable) AllIcons.Nodes.Variable else AllIcons.Nodes.Field
|
||||
@@ -439,7 +452,11 @@ class LyngCompletionContributor : CompletionContributor() {
|
||||
val builder = LookupElementBuilder.create(name)
|
||||
.withIcon(icon)
|
||||
.withTypeText(typeOf(chosen.type), true)
|
||||
emit(builder)
|
||||
if (groupPriority != 0.0) {
|
||||
emit(PrioritizedLookupElement.withPriority(builder, groupPriority))
|
||||
} else {
|
||||
emit(builder)
|
||||
}
|
||||
}
|
||||
is MiniInitDecl -> {}
|
||||
}
|
||||
@@ -447,8 +464,8 @@ class LyngCompletionContributor : CompletionContributor() {
|
||||
}
|
||||
|
||||
// Emit what we have first
|
||||
emitGroup(directMap)
|
||||
emitGroup(inheritedMap)
|
||||
emitGroup(directMap, 100.0)
|
||||
emitGroup(inheritedMap, 0.0)
|
||||
|
||||
// If suggestions are suspiciously sparse for known container classes,
|
||||
// try to conservatively supplement using a curated list resolved via docs registry.
|
||||
@@ -509,7 +526,7 @@ class LyngCompletionContributor : CompletionContributor() {
|
||||
.withInsertHandler(ParenInsertHandler)
|
||||
}
|
||||
}
|
||||
emit(builder)
|
||||
emit(PrioritizedLookupElement.withPriority(builder, 50.0))
|
||||
already.add(name)
|
||||
} else {
|
||||
// Synthetic fallback: method without detailed params/types to improve UX in absence of docs
|
||||
@@ -523,7 +540,7 @@ class LyngCompletionContributor : CompletionContributor() {
|
||||
.withTailText("()", true)
|
||||
.withInsertHandler(ParenInsertHandler)
|
||||
}
|
||||
emit(builder)
|
||||
emit(PrioritizedLookupElement.withPriority(builder, 50.0))
|
||||
already.add(name)
|
||||
}
|
||||
}
|
||||
@@ -576,7 +593,7 @@ class LyngCompletionContributor : CompletionContributor() {
|
||||
.withInsertHandler(ParenInsertHandler)
|
||||
}
|
||||
}
|
||||
emit(builder)
|
||||
emit(PrioritizedLookupElement.withPriority(builder, 50.0))
|
||||
already.add(name)
|
||||
continue
|
||||
}
|
||||
@@ -585,38 +602,16 @@ class LyngCompletionContributor : CompletionContributor() {
|
||||
.withIcon(AllIcons.Nodes.Method)
|
||||
.withTailText("()", true)
|
||||
.withInsertHandler(ParenInsertHandler)
|
||||
emit(builder)
|
||||
emit(PrioritizedLookupElement.withPriority(builder, 50.0))
|
||||
already.add(name)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Lenient textual import extractor (duplicated from QuickDoc privately)
|
||||
private fun extractImportsFromText(text: String): List<String> {
|
||||
val result = LinkedHashSet<String>()
|
||||
val re = Regex("^\\s*import\\s+([a-zA-Z_][a-zA-Z0-9_]*(?:\\.[a-zA-Z_][a-zA-Z0-9_]*)*)", RegexOption.MULTILINE)
|
||||
re.findAll(text).forEach { m ->
|
||||
val raw = m.groupValues.getOrNull(1)?.trim().orEmpty()
|
||||
if (raw.isNotEmpty()) {
|
||||
val canon = if (raw.startsWith("lyng.")) raw else "lyng.$raw"
|
||||
result.add(canon)
|
||||
}
|
||||
}
|
||||
return result.toList()
|
||||
}
|
||||
|
||||
private fun typeOf(t: MiniTypeRef?): String {
|
||||
return when (t) {
|
||||
null -> ""
|
||||
is MiniTypeName -> t.segments.lastOrNull()?.name?.let { ": $it" } ?: ""
|
||||
is MiniGenericType -> {
|
||||
val base = typeOf(t.base).removePrefix(": ")
|
||||
val args = t.args.joinToString(",") { typeOf(it).removePrefix(": ") }
|
||||
": ${base}<${args}>"
|
||||
}
|
||||
is MiniFunctionType -> ": (fn)"
|
||||
is MiniTypeVar -> ": ${t.name}"
|
||||
}
|
||||
val s = DocLookupUtils.typeOf(t)
|
||||
return if (s.isEmpty()) "" else ": $s"
|
||||
}
|
||||
}
|
||||
}
|
||||
+86
-26
@@ -461,25 +461,39 @@ class LyngDocumentationProvider : AbstractDocumentationProvider() {
|
||||
private fun ensureExternalDocsRegistered() { @Suppress("UNUSED_EXPRESSION") externalDocsLoaded }
|
||||
|
||||
private fun tryLoadExternalDocs(): Boolean {
|
||||
return try {
|
||||
var anyLoaded = false
|
||||
try {
|
||||
// Try known registrars; ignore failures if module is absent
|
||||
val cls = Class.forName("net.sergeych.lyngio.docs.FsBuiltinDocs")
|
||||
val m = cls.getMethod("ensure")
|
||||
m.invoke(null)
|
||||
log.info("[LYNG_DEBUG] QuickDoc: external docs loaded: net.sergeych.lyngio.docs.FsBuiltinDocs.ensure() OK")
|
||||
true
|
||||
} catch (_: Throwable) {
|
||||
anyLoaded = true
|
||||
} catch (_: Throwable) {}
|
||||
|
||||
try {
|
||||
val cls = Class.forName("net.sergeych.lyngio.docs.ProcessBuiltinDocs")
|
||||
val m = cls.getMethod("ensure")
|
||||
m.invoke(null)
|
||||
log.info("[LYNG_DEBUG] QuickDoc: external docs loaded: net.sergeych.lyngio.docs.ProcessBuiltinDocs.ensure() OK")
|
||||
anyLoaded = true
|
||||
} catch (_: Throwable) {}
|
||||
|
||||
if (!anyLoaded) {
|
||||
// Seed a minimal plugin-local fallback so Path docs still work without lyngio
|
||||
val seeded = try {
|
||||
FsDocsFallback.ensureOnce()
|
||||
ProcessDocsFallback.ensureOnce()
|
||||
true
|
||||
} catch (_: Throwable) { false }
|
||||
if (seeded) {
|
||||
log.info("[LYNG_DEBUG] QuickDoc: external docs NOT found; seeded plugin fallback for lyng.io.fs")
|
||||
log.info("[LYNG_DEBUG] QuickDoc: external docs NOT found; seeded plugin fallbacks")
|
||||
} else {
|
||||
log.info("[LYNG_DEBUG] QuickDoc: external docs NOT found (lyngio absent on classpath)")
|
||||
}
|
||||
seeded
|
||||
return seeded
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
override fun getCustomDocumentationElement(
|
||||
@@ -504,18 +518,26 @@ class LyngDocumentationProvider : AbstractDocumentationProvider() {
|
||||
if (d.mutable) "var ${d.name}${typeStr}" else "val ${d.name}${typeStr}"
|
||||
}
|
||||
}
|
||||
// Show full detailed documentation, not just the summary
|
||||
val raw = d.doc?.raw
|
||||
val doc: String? = if (raw.isNullOrBlank()) null else MarkdownRenderer.render(raw)
|
||||
val sb = StringBuilder()
|
||||
sb.append("<div class='doc-title'>").append(htmlEscape(title)).append("</div>")
|
||||
if (!doc.isNullOrBlank()) sb.append(styledMarkdown(doc))
|
||||
sb.append(renderDocBody(d.doc))
|
||||
return sb.toString()
|
||||
}
|
||||
|
||||
private fun renderParamDoc(fn: MiniFunDecl, p: MiniParam): String {
|
||||
val title = "parameter ${p.name}${typeOf(p.type)} in ${fn.name}${signatureOf(fn)}"
|
||||
return "<div class='doc-title'>${htmlEscape(title)}</div>"
|
||||
val sb = StringBuilder()
|
||||
sb.append("<div class='doc-title'>").append(htmlEscape(title)).append("</div>")
|
||||
|
||||
// Find matching @param tag
|
||||
fn.doc?.tags?.get("param")?.forEach { tag ->
|
||||
val parts = tag.split(Regex("\\s+"), 2)
|
||||
if (parts.getOrNull(0) == p.name && parts.size > 1) {
|
||||
sb.append(styledMarkdown(MarkdownRenderer.render(parts[1])))
|
||||
}
|
||||
}
|
||||
|
||||
return sb.toString()
|
||||
}
|
||||
|
||||
private fun renderMemberFunDoc(className: String, m: MiniMemberFunDecl): String {
|
||||
@@ -526,11 +548,9 @@ class LyngDocumentationProvider : AbstractDocumentationProvider() {
|
||||
val ret = typeOf(m.returnType)
|
||||
val staticStr = if (m.isStatic) "static " else ""
|
||||
val title = "${staticStr}method $className.${m.name}(${params})${ret}"
|
||||
val raw = m.doc?.raw
|
||||
val doc: String? = if (raw.isNullOrBlank()) null else MarkdownRenderer.render(raw)
|
||||
val sb = StringBuilder()
|
||||
sb.append("<div class='doc-title'>").append(htmlEscape(title)).append("</div>")
|
||||
if (!doc.isNullOrBlank()) sb.append(styledMarkdown(doc))
|
||||
sb.append(renderDocBody(m.doc))
|
||||
return sb.toString()
|
||||
}
|
||||
|
||||
@@ -539,24 +559,15 @@ class LyngDocumentationProvider : AbstractDocumentationProvider() {
|
||||
val kind = if (m.mutable) "var" else "val"
|
||||
val staticStr = if (m.isStatic) "static " else ""
|
||||
val title = "${staticStr}${kind} $className.${m.name}${ts}"
|
||||
val raw = m.doc?.raw
|
||||
val doc: String? = if (raw.isNullOrBlank()) null else MarkdownRenderer.render(raw)
|
||||
val sb = StringBuilder()
|
||||
sb.append("<div class='doc-title'>").append(htmlEscape(title)).append("</div>")
|
||||
if (!doc.isNullOrBlank()) sb.append(styledMarkdown(doc))
|
||||
sb.append(renderDocBody(m.doc))
|
||||
return sb.toString()
|
||||
}
|
||||
|
||||
private fun typeOf(t: MiniTypeRef?): String = when (t) {
|
||||
is MiniTypeName -> ": ${t.segments.joinToString(".") { it.name }}${if (t.nullable) "?" else ""}"
|
||||
is MiniGenericType -> {
|
||||
val base = typeOf(t.base).removePrefix(": ")
|
||||
val args = t.args.joinToString(", ") { typeOf(it).removePrefix(": ") }
|
||||
": ${base}<${args}>${if (t.nullable) "?" else ""}"
|
||||
}
|
||||
is MiniFunctionType -> ": (..) -> ..${if (t.nullable) "?" else ""}"
|
||||
is MiniTypeVar -> ": ${t.name}${if (t.nullable) "?" else ""}"
|
||||
null -> ": Object?"
|
||||
private fun typeOf(t: MiniTypeRef?): String {
|
||||
val s = DocLookupUtils.typeOf(t)
|
||||
return if (s.isEmpty()) (if (t == null) ": Object?" else "") else ": $s"
|
||||
}
|
||||
|
||||
private fun signatureOf(fn: MiniFunDecl): String {
|
||||
@@ -656,6 +667,55 @@ class LyngDocumentationProvider : AbstractDocumentationProvider() {
|
||||
return if (e > s) TextRange(s, e) else null
|
||||
}
|
||||
|
||||
private fun renderDocBody(doc: MiniDoc?): String {
|
||||
if (doc == null) return ""
|
||||
val sb = StringBuilder()
|
||||
if (doc.raw.isNotBlank()) {
|
||||
sb.append(styledMarkdown(MarkdownRenderer.render(doc.raw)))
|
||||
}
|
||||
if (doc.tags.isNotEmpty()) {
|
||||
sb.append(renderTags(doc.tags))
|
||||
}
|
||||
return sb.toString()
|
||||
}
|
||||
|
||||
private fun renderTags(tags: Map<String, List<String>>): String {
|
||||
if (tags.isEmpty()) return ""
|
||||
val sb = StringBuilder()
|
||||
sb.append("<table class='sections'>")
|
||||
|
||||
fun section(title: String, list: List<String>, isKeyValue: Boolean = false) {
|
||||
if (list.isEmpty()) return
|
||||
sb.append("<tr><td valign='top' class='section'><p>").append(htmlEscape(title)).append(":</p></td><td valign='top'>")
|
||||
list.forEachIndexed { index, item ->
|
||||
if (index > 0) sb.append("<p>")
|
||||
if (isKeyValue) {
|
||||
val parts = item.split(Regex("\\s+"), 2)
|
||||
sb.append("<code>").append(htmlEscape(parts[0])).append("</code>")
|
||||
if (parts.size > 1) {
|
||||
sb.append(" — ").append(MarkdownRenderer.render(parts[1]).removePrefix("<p>").removeSuffix("</p>"))
|
||||
}
|
||||
} else {
|
||||
sb.append(MarkdownRenderer.render(item).removePrefix("<p>").removeSuffix("</p>"))
|
||||
}
|
||||
}
|
||||
sb.append("</td></tr>")
|
||||
}
|
||||
|
||||
section("Parameters", tags["param"] ?: emptyList(), isKeyValue = true)
|
||||
section("Returns", tags["return"] ?: emptyList())
|
||||
section("Throws", tags["throws"] ?: emptyList(), isKeyValue = true)
|
||||
|
||||
tags.forEach { (name, list) ->
|
||||
if (name !in listOf("param", "return", "throws")) {
|
||||
section(name.replaceFirstChar { if (it.isLowerCase()) it.titlecase() else it.toString() }, list)
|
||||
}
|
||||
}
|
||||
|
||||
sb.append("</table>")
|
||||
return sb.toString()
|
||||
}
|
||||
|
||||
private fun previousWordBefore(text: String, offset: Int): TextRange? {
|
||||
// skip spaces and the dot to the left, but stop after hitting a non-identifier boundary
|
||||
var i = (offset - 1).coerceAtLeast(0)
|
||||
|
||||
@@ -0,0 +1,69 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* Minimal fallback docs seeding for `lyng.io.process` used only inside the IDEA plugin
|
||||
* when external docs module (lyngio) is not present on the classpath.
|
||||
*/
|
||||
package net.sergeych.lyng.idea.docs
|
||||
|
||||
import net.sergeych.lyng.miniast.BuiltinDocRegistry
|
||||
import net.sergeych.lyng.miniast.ParamDoc
|
||||
import net.sergeych.lyng.miniast.type
|
||||
|
||||
internal object ProcessDocsFallback {
|
||||
@Volatile
|
||||
private var seeded = false
|
||||
|
||||
fun ensureOnce(): Boolean {
|
||||
if (seeded) return true
|
||||
synchronized(this) {
|
||||
if (seeded) return true
|
||||
BuiltinDocRegistry.module("lyng.io.process") {
|
||||
classDoc(name = "Process", doc = "Process execution and control.") {
|
||||
method(
|
||||
name = "execute",
|
||||
doc = "Execute a process with arguments.",
|
||||
params = listOf(ParamDoc("executable", type("lyng.String")), ParamDoc("args", type("lyng.List"))),
|
||||
returns = type("RunningProcess"),
|
||||
isStatic = true
|
||||
)
|
||||
method(
|
||||
name = "shell",
|
||||
doc = "Execute a command via system shell.",
|
||||
params = listOf(ParamDoc("command", type("lyng.String"))),
|
||||
returns = type("RunningProcess"),
|
||||
isStatic = true
|
||||
)
|
||||
}
|
||||
|
||||
classDoc(name = "RunningProcess", doc = "Handle to a running process.") {
|
||||
method(name = "stdout", doc = "Get standard output stream as a Flow of lines.", returns = type("lyng.Flow"))
|
||||
method(name = "stderr", doc = "Get standard error stream as a Flow of lines.", returns = type("lyng.Flow"))
|
||||
method(name = "waitFor", doc = "Wait for the process to exit.", returns = type("lyng.Int"))
|
||||
method(name = "signal", doc = "Send a signal to the process.", params = listOf(ParamDoc("signal", type("lyng.String"))))
|
||||
method(name = "destroy", doc = "Forcefully terminate the process.")
|
||||
}
|
||||
|
||||
valDoc(name = "Process", doc = "Process execution and control.", type = type("Process"))
|
||||
valDoc(name = "RunningProcess", doc = "Handle to a running process.", type = type("RunningProcess"))
|
||||
}
|
||||
seeded = true
|
||||
return true
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,43 +0,0 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
package net.sergeych.lyng.idea.grazie
|
||||
|
||||
import com.intellij.codeInsight.daemon.DaemonCodeAnalyzer
|
||||
import com.intellij.codeInsight.intention.IntentionAction
|
||||
import com.intellij.openapi.editor.Editor
|
||||
import com.intellij.openapi.project.Project
|
||||
import com.intellij.psi.PsiFile
|
||||
import net.sergeych.lyng.idea.settings.LyngFormatterSettings
|
||||
|
||||
/**
|
||||
* Lightweight quick-fix that adds a word to the per-project Lyng dictionary.
|
||||
*/
|
||||
class AddToLyngDictionaryFix(private val word: String) : IntentionAction {
|
||||
override fun getText(): String = "Add '$word' to Lyng dictionary"
|
||||
override fun getFamilyName(): String = "Lyng Spelling"
|
||||
override fun isAvailable(project: Project, editor: Editor?, file: PsiFile?): Boolean = word.isNotBlank()
|
||||
override fun startInWriteAction(): Boolean = true
|
||||
|
||||
override fun invoke(project: Project, editor: Editor?, file: PsiFile?) {
|
||||
val settings = LyngFormatterSettings.getInstance(project)
|
||||
val learned = settings.learnedWords
|
||||
learned.add(word.lowercase())
|
||||
settings.learnedWords = learned
|
||||
// Restart daemon to refresh highlights
|
||||
if (file != null) DaemonCodeAnalyzer.getInstance(project).restart(file)
|
||||
}
|
||||
}
|
||||
@@ -1,83 +0,0 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
package net.sergeych.lyng.idea.grazie
|
||||
|
||||
import com.intellij.openapi.diagnostic.Logger
|
||||
import java.io.BufferedReader
|
||||
import java.io.InputStreamReader
|
||||
import java.util.zip.GZIPInputStream
|
||||
|
||||
/**
|
||||
* Very simple English dictionary loader for offline suggestions on IC-243.
|
||||
* It loads a word list from classpath resources. Supports plain text (one word per line)
|
||||
* and gzipped text if the resource ends with .gz.
|
||||
*/
|
||||
object EnglishDictionary {
|
||||
private val log = Logger.getInstance(EnglishDictionary::class.java)
|
||||
|
||||
@Volatile private var loaded = false
|
||||
@Volatile private var words: Set<String> = emptySet()
|
||||
|
||||
/**
|
||||
* Load dictionary from bundled resources (once).
|
||||
* If multiple candidates exist, the first found is used.
|
||||
*/
|
||||
private fun ensureLoaded() {
|
||||
if (loaded) return
|
||||
synchronized(this) {
|
||||
if (loaded) return
|
||||
val candidates = listOf(
|
||||
// preferred large bundles first (add en-basic.txt.gz ~3–5MB here)
|
||||
"/dictionaries/en-basic.txt.gz",
|
||||
"/dictionaries/en-large.txt.gz",
|
||||
// plain text fallbacks
|
||||
"/dictionaries/en-basic.txt",
|
||||
"/dictionaries/en-large.txt",
|
||||
)
|
||||
val merged = HashSet<String>(128_000)
|
||||
for (res in candidates) {
|
||||
try {
|
||||
val stream = javaClass.getResourceAsStream(res) ?: continue
|
||||
val reader = if (res.endsWith(".gz"))
|
||||
BufferedReader(InputStreamReader(GZIPInputStream(stream)))
|
||||
else
|
||||
BufferedReader(InputStreamReader(stream))
|
||||
var loadedCount = 0
|
||||
reader.useLines { seq -> seq.forEach { line ->
|
||||
val w = line.trim()
|
||||
if (w.isNotEmpty() && !w.startsWith("#")) { merged += w.lowercase(); loadedCount++ }
|
||||
} }
|
||||
log.info("EnglishDictionary: loaded $loadedCount words from $res (total=${merged.size})")
|
||||
} catch (t: Throwable) {
|
||||
log.info("EnglishDictionary: failed to load $res: ${t.javaClass.simpleName}: ${t.message}")
|
||||
}
|
||||
}
|
||||
if (merged.isEmpty()) {
|
||||
// Fallback minimal set
|
||||
merged += setOf("comment","comments","error","errors","found","file","not","word","words","count","value","name","class","function","string")
|
||||
log.info("EnglishDictionary: using minimal built-in set (${merged.size})")
|
||||
}
|
||||
words = merged
|
||||
loaded = true
|
||||
}
|
||||
}
|
||||
|
||||
fun allWords(): Set<String> {
|
||||
ensureLoaded()
|
||||
return words
|
||||
}
|
||||
}
|
||||
@@ -1,609 +0,0 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* Grazie-backed annotator for Lyng files.
|
||||
*
|
||||
* It consumes the MiniAst-driven LyngSpellIndex and, when Grazie is present,
|
||||
* tries to run Grazie checks on the extracted TextContent. Results are painted
|
||||
* as warnings in the editor. If the Grazie API changes, we use reflection and
|
||||
* fail softly with INFO logs (no errors shown to users).
|
||||
*/
|
||||
package net.sergeych.lyng.idea.grazie
|
||||
|
||||
import com.intellij.codeInsight.daemon.DaemonCodeAnalyzer
|
||||
import com.intellij.grazie.text.TextContent
|
||||
import com.intellij.grazie.text.TextContent.TextDomain
|
||||
import com.intellij.ide.plugins.PluginManagerCore
|
||||
import com.intellij.lang.annotation.AnnotationHolder
|
||||
import com.intellij.lang.annotation.ExternalAnnotator
|
||||
import com.intellij.lang.annotation.HighlightSeverity
|
||||
import com.intellij.openapi.application.ApplicationManager
|
||||
import com.intellij.openapi.diagnostic.Logger
|
||||
import com.intellij.openapi.editor.Document
|
||||
import com.intellij.openapi.editor.colors.TextAttributesKey
|
||||
import com.intellij.openapi.project.DumbAware
|
||||
import com.intellij.openapi.util.Key
|
||||
import com.intellij.openapi.util.TextRange
|
||||
import com.intellij.psi.PsiFile
|
||||
import net.sergeych.lyng.idea.settings.LyngFormatterSettings
|
||||
import net.sergeych.lyng.idea.spell.LyngSpellIndex
|
||||
|
||||
class LyngGrazieAnnotator : ExternalAnnotator<LyngGrazieAnnotator.Input, LyngGrazieAnnotator.Result>(), DumbAware {
|
||||
private val log = Logger.getInstance(LyngGrazieAnnotator::class.java)
|
||||
|
||||
companion object {
|
||||
// Cache GrammarChecker availability to avoid repeated reflection + noisy logs
|
||||
@Volatile
|
||||
private var grammarCheckerAvailable: Boolean? = null
|
||||
|
||||
@Volatile
|
||||
private var grammarCheckerMissingLogged: Boolean = false
|
||||
|
||||
private fun isGrammarCheckerKnownMissing(): Boolean = (grammarCheckerAvailable == false)
|
||||
|
||||
private fun markGrammarCheckerMissingOnce(log: Logger, message: String) {
|
||||
if (!grammarCheckerMissingLogged) {
|
||||
// Downgrade to debug to reduce log noise across projects/sessions
|
||||
log.debug(message)
|
||||
grammarCheckerMissingLogged = true
|
||||
}
|
||||
}
|
||||
|
||||
private val RETRY_KEY: Key<Long> = Key.create("LYNG_GRAZIE_ANN_RETRY_STAMP")
|
||||
}
|
||||
|
||||
data class Input(val modStamp: Long)
|
||||
data class Finding(val range: TextRange, val message: String)
|
||||
data class Result(val modStamp: Long, val findings: List<Finding>)
|
||||
|
||||
override fun collectInformation(file: PsiFile): Input? {
|
||||
val doc: Document = file.viewProvider.document ?: return null
|
||||
// Only require Grazie presence; index readiness is checked in apply with a retry.
|
||||
val grazie = isGrazieInstalled()
|
||||
if (!grazie) {
|
||||
log.info("LyngGrazieAnnotator.collectInformation: skip (grazie=false) file='${file.name}'")
|
||||
return null
|
||||
}
|
||||
log.info("LyngGrazieAnnotator.collectInformation: file='${file.name}', modStamp=${doc.modificationStamp}")
|
||||
return Input(doc.modificationStamp)
|
||||
}
|
||||
|
||||
override fun doAnnotate(collectedInfo: Input?): Result? {
|
||||
// All heavy lifting is done in apply where we have the file context
|
||||
return collectedInfo?.let { Result(it.modStamp, emptyList()) }
|
||||
}
|
||||
|
||||
override fun apply(file: PsiFile, annotationResult: Result?, holder: AnnotationHolder) {
|
||||
if (annotationResult == null || !isGrazieInstalled()) return
|
||||
val doc = file.viewProvider.document ?: return
|
||||
val idx = LyngSpellIndex.getUpToDate(file) ?: run {
|
||||
log.info("LyngGrazieAnnotator.apply: index not ready for '${file.name}', scheduling one-shot restart")
|
||||
scheduleOneShotRestart(file, annotationResult.modStamp)
|
||||
return
|
||||
}
|
||||
|
||||
val settings = LyngFormatterSettings.getInstance(file.project)
|
||||
|
||||
// Build TextContent fragments for comments/strings/identifiers according to settings
|
||||
val fragments = mutableListOf<Pair<TextContent, TextRange>>()
|
||||
try {
|
||||
fun addFragments(ranges: List<TextRange>, domain: TextDomain) {
|
||||
for (r in ranges) {
|
||||
val local = rangeToTextContent(file, domain, r) ?: continue
|
||||
fragments += local to r
|
||||
}
|
||||
}
|
||||
// Comments always via COMMENTS
|
||||
addFragments(idx.comments, TextDomain.COMMENTS)
|
||||
// Strings: LITERALS if requested, else COMMENTS if fallback enabled
|
||||
if (settings.spellCheckStringLiterals) {
|
||||
val domain = if (settings.grazieTreatLiteralsAsComments) TextDomain.COMMENTS else TextDomain.LITERALS
|
||||
addFragments(idx.strings, domain)
|
||||
}
|
||||
// Identifiers via COMMENTS to force painting in 243 unless user disables fallback
|
||||
val idsDomain = if (settings.grazieTreatIdentifiersAsComments) TextDomain.COMMENTS else TextDomain.DOCUMENTATION
|
||||
addFragments(idx.identifiers, idsDomain)
|
||||
log.info(
|
||||
"LyngGrazieAnnotator.apply: file='${file.name}', idxCounts ids=${idx.identifiers.size}, comments=${idx.comments.size}, strings=${idx.strings.size}, builtFragments=${fragments.size}"
|
||||
)
|
||||
} catch (e: Throwable) {
|
||||
log.info("LyngGrazieAnnotator: failed to build TextContent fragments: ${e.javaClass.simpleName}: ${e.message}")
|
||||
return
|
||||
}
|
||||
|
||||
if (fragments.isEmpty()) return
|
||||
|
||||
val findings = mutableListOf<Finding>()
|
||||
var totalReturned = 0
|
||||
var chosenEntry: String? = null
|
||||
for ((content, hostRange) in fragments) {
|
||||
try {
|
||||
val (typos, entryNote) = runGrazieChecksWithTracing(file, content)
|
||||
if (chosenEntry == null) chosenEntry = entryNote
|
||||
if (typos != null) {
|
||||
totalReturned += typos.size
|
||||
for (t in typos) {
|
||||
val rel = extractRangeFromTypo(t) ?: continue
|
||||
// Map relative range inside fragment to host file range
|
||||
val abs = TextRange(hostRange.startOffset + rel.startOffset, hostRange.startOffset + rel.endOffset)
|
||||
findings += Finding(abs, extractMessageFromTypo(t) ?: "Spelling/Grammar")
|
||||
}
|
||||
}
|
||||
} catch (e: Throwable) {
|
||||
log.info("LyngGrazieAnnotator: Grazie check failed: ${e.javaClass.simpleName}: ${e.message}")
|
||||
}
|
||||
}
|
||||
log.info("LyngGrazieAnnotator.apply: used=${chosenEntry ?: "<none>"}, totalFindings=$totalReturned, painting=${findings.size}")
|
||||
|
||||
// IMPORTANT: Do NOT fallback to the tiny bundled vocabulary on modern IDEs.
|
||||
// If Grazie/Natural Languages processing returned nothing, we simply exit here
|
||||
// to avoid low‑quality results from the legacy dictionary.
|
||||
if (findings.isEmpty()) return
|
||||
|
||||
for (f in findings) {
|
||||
val ab = holder.newAnnotation(HighlightSeverity.INFORMATION, f.message).range(f.range)
|
||||
applyTypoStyleIfRequested(file, ab)
|
||||
ab.create()
|
||||
}
|
||||
}
|
||||
|
||||
private fun scheduleOneShotRestart(file: PsiFile, modStamp: Long) {
|
||||
try {
|
||||
val last = file.getUserData(RETRY_KEY)
|
||||
if (last == modStamp) {
|
||||
log.info("LyngGrazieAnnotator.restart: already retried for modStamp=$modStamp, skip")
|
||||
return
|
||||
}
|
||||
file.putUserData(RETRY_KEY, modStamp)
|
||||
ApplicationManager.getApplication().invokeLater({
|
||||
try {
|
||||
DaemonCodeAnalyzer.getInstance(file.project).restart(file)
|
||||
log.info("LyngGrazieAnnotator.restart: daemon restarted for '${file.name}'")
|
||||
} catch (e: Throwable) {
|
||||
log.info("LyngGrazieAnnotator.restart failed: ${e.javaClass.simpleName}: ${e.message}")
|
||||
}
|
||||
})
|
||||
} catch (e: Throwable) {
|
||||
log.info("LyngGrazieAnnotator.scheduleOneShotRestart failed: ${e.javaClass.simpleName}: ${e.message}")
|
||||
}
|
||||
}
|
||||
|
||||
private fun isGrazieInstalled(): Boolean {
|
||||
return PluginManagerCore.isPluginInstalled(com.intellij.openapi.extensions.PluginId.getId("com.intellij.grazie")) ||
|
||||
PluginManagerCore.isPluginInstalled(com.intellij.openapi.extensions.PluginId.getId("tanvd.grazi"))
|
||||
}
|
||||
|
||||
private fun rangeToTextContent(file: PsiFile, domain: TextDomain, range: TextRange): TextContent? {
|
||||
// Build TextContent via reflection: prefer psiFragment(domain, element)
|
||||
return try {
|
||||
// Try to find an element that fully covers the target range
|
||||
var element = file.findElementAt(range.startOffset) ?: return null
|
||||
val start = range.startOffset
|
||||
val end = range.endOffset
|
||||
while (element.parent != null && (element.textRange.startOffset > start || element.textRange.endOffset < end)) {
|
||||
element = element.parent
|
||||
}
|
||||
if (element.textRange.startOffset > start || element.textRange.endOffset < end) return null
|
||||
// In many cases, the element may not span the whole range; use file + range via suitable factory
|
||||
val methods = TextContent::class.java.methods.filter { it.name == "psiFragment" }
|
||||
val byElementDomain = methods.firstOrNull { it.parameterCount == 2 && it.parameterTypes[0].name.endsWith("PsiElement") }
|
||||
if (byElementDomain != null) {
|
||||
@Suppress("UNCHECKED_CAST")
|
||||
return (byElementDomain.invoke(null, element, domain) as? TextContent)?.let { tc ->
|
||||
val relStart = start - element.textRange.startOffset
|
||||
val relEnd = end - element.textRange.startOffset
|
||||
if (relStart < 0 || relEnd > tc.length || relStart >= relEnd) return null
|
||||
tc.subText(TextRange(relStart, relEnd))
|
||||
}
|
||||
}
|
||||
val byDomainElement = methods.firstOrNull { it.parameterCount == 2 && it.parameterTypes[0].name.endsWith("TextDomain") }
|
||||
if (byDomainElement != null) {
|
||||
@Suppress("UNCHECKED_CAST")
|
||||
return (byDomainElement.invoke(null, domain, element) as? TextContent)?.let { tc ->
|
||||
val relStart = start - element.textRange.startOffset
|
||||
val relEnd = end - element.textRange.startOffset
|
||||
if (relStart < 0 || relEnd > tc.length || relStart >= relEnd) return null
|
||||
tc.subText(TextRange(relStart, relEnd))
|
||||
}
|
||||
}
|
||||
null
|
||||
} catch (e: Throwable) {
|
||||
log.info("LyngGrazieAnnotator: rangeToTextContent failed: ${e.javaClass.simpleName}: ${e.message}")
|
||||
null
|
||||
}
|
||||
}
|
||||
|
||||
private fun runGrazieChecksWithTracing(file: PsiFile, content: TextContent): Pair<Collection<Any>?, String?> {
|
||||
// Try known entry points via reflection to avoid hard dependencies on Grazie internals
|
||||
if (isGrammarCheckerKnownMissing()) return null to null
|
||||
try {
|
||||
// 1) Static GrammarChecker.check(TextContent)
|
||||
val checkerCls = try {
|
||||
Class.forName("com.intellij.grazie.grammar.GrammarChecker").also { grammarCheckerAvailable = true }
|
||||
} catch (t: Throwable) {
|
||||
grammarCheckerAvailable = false
|
||||
markGrammarCheckerMissingOnce(log, "LyngGrazieAnnotator: GrammarChecker class not found: ${t.javaClass.simpleName}: ${t.message}")
|
||||
null
|
||||
}
|
||||
if (checkerCls != null) {
|
||||
// Diagnostic: list available 'check' methods once
|
||||
runCatching {
|
||||
val checks = checkerCls.methods.filter { it.name == "check" }
|
||||
val sig = checks.joinToString { m ->
|
||||
val params = m.parameterTypes.joinToString(prefix = "(", postfix = ")") { it.simpleName }
|
||||
"${m.name}$params static=${java.lang.reflect.Modifier.isStatic(m.modifiers)}"
|
||||
}
|
||||
log.info("LyngGrazieAnnotator: GrammarChecker.check candidates: ${if (sig.isEmpty()) "<none>" else sig}")
|
||||
}
|
||||
checkerCls.methods.firstOrNull { it.name == "check" && it.parameterCount == 1 && it.parameterTypes[0].name.endsWith("TextContent") }?.let { m ->
|
||||
@Suppress("UNCHECKED_CAST")
|
||||
val res = m.invoke(null, content) as? Collection<Any>
|
||||
return res to "GrammarChecker.check(TextContent) static"
|
||||
}
|
||||
// 2) GrammarChecker.getInstance().check(TextContent)
|
||||
val getInstance = checkerCls.methods.firstOrNull { it.name == "getInstance" && it.parameterCount == 0 }
|
||||
val inst = getInstance?.invoke(null)
|
||||
if (inst != null) {
|
||||
val m = checkerCls.methods.firstOrNull { it.name == "check" && it.parameterCount == 1 && it.parameterTypes[0].name.endsWith("TextContent") }
|
||||
if (m != null) {
|
||||
@Suppress("UNCHECKED_CAST")
|
||||
val res = m.invoke(inst, content) as? Collection<Any>
|
||||
return res to "GrammarChecker.getInstance().check(TextContent)"
|
||||
}
|
||||
}
|
||||
// 3) GrammarChecker.getDefault().check(TextContent)
|
||||
val getDefault = checkerCls.methods.firstOrNull { it.name == "getDefault" && it.parameterCount == 0 }
|
||||
val def = getDefault?.invoke(null)
|
||||
if (def != null) {
|
||||
val m = checkerCls.methods.firstOrNull { it.name == "check" && it.parameterCount == 1 && it.parameterTypes[0].name.endsWith("TextContent") }
|
||||
if (m != null) {
|
||||
@Suppress("UNCHECKED_CAST")
|
||||
val res = m.invoke(def, content) as? Collection<Any>
|
||||
return res to "GrammarChecker.getDefault().check(TextContent)"
|
||||
}
|
||||
}
|
||||
// 4) Service from project/application: GrammarChecker as a service
|
||||
runCatching {
|
||||
val app = com.intellij.openapi.application.ApplicationManager.getApplication()
|
||||
val getService = app::class.java.methods.firstOrNull { it.name == "getService" && it.parameterCount == 1 }
|
||||
val svc = getService?.invoke(app, checkerCls)
|
||||
if (svc != null) {
|
||||
val m = checkerCls.methods.firstOrNull { it.name == "check" && it.parameterCount == 1 && it.parameterTypes[0].name.endsWith("TextContent") }
|
||||
if (m != null) {
|
||||
@Suppress("UNCHECKED_CAST")
|
||||
val res = m.invoke(svc, content) as? Collection<Any>
|
||||
if (res != null) return res to "Application.getService(GrammarChecker).check(TextContent)"
|
||||
}
|
||||
}
|
||||
}
|
||||
runCatching {
|
||||
val getService = file.project::class.java.methods.firstOrNull { it.name == "getService" && it.parameterCount == 1 }
|
||||
val svc = getService?.invoke(file.project, checkerCls)
|
||||
if (svc != null) {
|
||||
val m = checkerCls.methods.firstOrNull { it.name == "check" && it.parameterCount == 1 && it.parameterTypes[0].name.endsWith("TextContent") }
|
||||
if (m != null) {
|
||||
@Suppress("UNCHECKED_CAST")
|
||||
val res = m.invoke(svc, content) as? Collection<Any>
|
||||
if (res != null) return res to "Project.getService(GrammarChecker).check(TextContent)"
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
// 5) Fallback: search any public method named check that accepts TextContent in any Grazie class (static)
|
||||
val candidateClasses = listOf(
|
||||
"com.intellij.grazie.grammar.GrammarChecker",
|
||||
"com.intellij.grazie.grammar.GrammarRunner",
|
||||
"com.intellij.grazie.grammar.Grammar" // historical names
|
||||
)
|
||||
for (cn in candidateClasses) {
|
||||
val cls = try { Class.forName(cn) } catch (_: Throwable) { continue }
|
||||
val m = cls.methods.firstOrNull { it.name == "check" && it.parameterTypes.any { p -> p.name.endsWith("TextContent") } }
|
||||
if (m != null) {
|
||||
val args = arrayOfNulls<Any>(m.parameterCount)
|
||||
// place content to the first TextContent parameter; others left null (common defaults)
|
||||
for (i in 0 until m.parameterCount) if (m.parameterTypes[i].name.endsWith("TextContent")) { args[i] = content; break }
|
||||
@Suppress("UNCHECKED_CAST")
|
||||
val res = m.invoke(null, *args) as? Collection<Any>
|
||||
if (res != null) return res to "$cn.${m.name}(TextContent)"
|
||||
}
|
||||
}
|
||||
// 6) Kotlin top-level function: GrammarCheckerKt.check(TextContent)
|
||||
runCatching {
|
||||
val kt = Class.forName("com.intellij.grazie.grammar.GrammarCheckerKt")
|
||||
val m = kt.methods.firstOrNull { it.name == "check" && it.parameterTypes.any { p -> p.name.endsWith("TextContent") } }
|
||||
if (m != null) {
|
||||
val args = arrayOfNulls<Any>(m.parameterCount)
|
||||
for (i in 0 until m.parameterCount) if (m.parameterTypes[i].name.endsWith("TextContent")) { args[i] = content; break }
|
||||
@Suppress("UNCHECKED_CAST")
|
||||
val res = m.invoke(null, *args) as? Collection<Any>
|
||||
if (res != null) return res to "GrammarCheckerKt.check(TextContent)"
|
||||
}
|
||||
}
|
||||
} catch (e: Throwable) {
|
||||
log.info("LyngGrazieAnnotator: runGrazieChecks reflection failed: ${e.javaClass.simpleName}: ${e.message}")
|
||||
}
|
||||
return null to null
|
||||
}
|
||||
|
||||
private fun extractRangeFromTypo(typo: Any): TextRange? {
|
||||
// Try to get a relative range from returned Grazie issue/typo via common accessors
|
||||
return try {
|
||||
// Common getters
|
||||
val m1 = typo.javaClass.methods.firstOrNull { it.name == "getRange" && it.parameterCount == 0 }
|
||||
val r1 = if (m1 != null) m1.invoke(typo) else null
|
||||
when (r1) {
|
||||
is TextRange -> return r1
|
||||
is IntRange -> return TextRange(r1.first, r1.last + 1)
|
||||
}
|
||||
val m2 = typo.javaClass.methods.firstOrNull { it.name == "getHighlightRange" && it.parameterCount == 0 }
|
||||
val r2 = if (m2 != null) m2.invoke(typo) else null
|
||||
when (r2) {
|
||||
is TextRange -> return r2
|
||||
is IntRange -> return TextRange(r2.first, r2.last + 1)
|
||||
}
|
||||
// Separate from/to ints
|
||||
val fromM = typo.javaClass.methods.firstOrNull { it.name == "getFrom" && it.parameterCount == 0 && it.returnType == Int::class.javaPrimitiveType }
|
||||
val toM = typo.javaClass.methods.firstOrNull { it.name == "getTo" && it.parameterCount == 0 && it.returnType == Int::class.javaPrimitiveType }
|
||||
if (fromM != null && toM != null) {
|
||||
val s = (fromM.invoke(typo) as? Int) ?: return null
|
||||
val e = (toM.invoke(typo) as? Int) ?: return null
|
||||
if (e > s) return TextRange(s, e)
|
||||
}
|
||||
null
|
||||
} catch (_: Throwable) { null }
|
||||
}
|
||||
|
||||
private fun extractMessageFromTypo(typo: Any): String? {
|
||||
return try {
|
||||
val m = typo.javaClass.methods.firstOrNull { it.name == "getMessage" && it.parameterCount == 0 }
|
||||
(m?.invoke(typo) as? String)
|
||||
} catch (_: Throwable) { null }
|
||||
}
|
||||
|
||||
|
||||
// Fallback that uses legacy SpellCheckerManager (if present) via reflection to validate words in fragments.
|
||||
// Returns number of warnings painted.
|
||||
private fun fallbackWithLegacySpellcheckerIfAvailable(
|
||||
file: PsiFile,
|
||||
fragments: List<Pair<TextContent, TextRange>>,
|
||||
holder: AnnotationHolder
|
||||
): Int {
|
||||
return try {
|
||||
val mgrCls = Class.forName("com.intellij.spellchecker.SpellCheckerManager")
|
||||
val getInstance = mgrCls.methods.firstOrNull { it.name == "getInstance" && it.parameterCount == 1 }
|
||||
val isCorrect = mgrCls.methods.firstOrNull { it.name == "isCorrect" && it.parameterCount == 1 && it.parameterTypes[0] == String::class.java }
|
||||
if (getInstance == null || isCorrect == null) {
|
||||
// No legacy spellchecker API available — fall back to naive painter
|
||||
return naiveFallbackPaint(file, fragments, holder)
|
||||
}
|
||||
val mgr = getInstance.invoke(null, file.project)
|
||||
if (mgr == null) {
|
||||
// Legacy manager not present for this project — use naive fallback
|
||||
return naiveFallbackPaint(file, fragments, holder)
|
||||
}
|
||||
var painted = 0
|
||||
val docText = file.viewProvider.document?.text ?: return 0
|
||||
val tokenRegex = Regex("[A-Za-z][A-Za-z0-9_']{2,}")
|
||||
for ((content, hostRange) in fragments) {
|
||||
val text = try { docText.substring(hostRange.startOffset, hostRange.endOffset) } catch (_: Throwable) { null } ?: continue
|
||||
var seen = 0
|
||||
var flagged = 0
|
||||
for (m in tokenRegex.findAll(text)) {
|
||||
val token = m.value
|
||||
if ('%' in token) continue // skip printf fragments defensively
|
||||
// Split snake_case and camelCase within the token
|
||||
val parts = splitIdentifier(token)
|
||||
for (part in parts) {
|
||||
if (part.length <= 2) continue
|
||||
if (isAllowedWord(part)) continue
|
||||
// Quick allowlist for very common words to reduce noise if dictionaries differ
|
||||
val ok = try { isCorrect.invoke(mgr, part) as? Boolean } catch (_: Throwable) { null }
|
||||
if (ok == false) {
|
||||
// Map part back to original token occurrence within this hostRange
|
||||
val localStart = m.range.first + token.indexOf(part)
|
||||
val localEnd = localStart + part.length
|
||||
val abs = TextRange(hostRange.startOffset + localStart, hostRange.startOffset + localEnd)
|
||||
paintTypoAnnotation(file, holder, abs, part)
|
||||
painted++
|
||||
flagged++
|
||||
}
|
||||
seen++
|
||||
}
|
||||
}
|
||||
log.info("LyngGrazieAnnotator.fallback: fragment words=$seen, flagged=$flagged")
|
||||
}
|
||||
painted
|
||||
} catch (_: Throwable) {
|
||||
// If legacy manager is not available, fall back to a very naive heuristic (no external deps)
|
||||
return naiveFallbackPaint(file, fragments, holder)
|
||||
}
|
||||
}
|
||||
|
||||
private fun naiveFallbackPaint(
|
||||
file: PsiFile,
|
||||
fragments: List<Pair<TextContent, TextRange>>,
|
||||
holder: AnnotationHolder
|
||||
): Int {
|
||||
var painted = 0
|
||||
val docText = file.viewProvider.document?.text
|
||||
val tokenRegex = Regex("[A-Za-z][A-Za-z0-9_']{2,}")
|
||||
val baseWords = setOf(
|
||||
// small, common vocabulary to catch near-miss typos in typical code/comments
|
||||
"comment","comments","error","errors","found","file","not","word","words","count","value","name","class","function","string"
|
||||
)
|
||||
for ((content, hostRange) in fragments) {
|
||||
val text: String? = docText?.let { dt ->
|
||||
try { dt.substring(hostRange.startOffset, hostRange.endOffset) } catch (_: Throwable) { null }
|
||||
}
|
||||
if (text.isNullOrBlank()) continue
|
||||
var seen = 0
|
||||
var flagged = 0
|
||||
for (m in tokenRegex.findAll(text)) {
|
||||
val token = m.value
|
||||
if ('%' in token) continue
|
||||
val parts = splitIdentifier(token)
|
||||
for (part in parts) {
|
||||
seen++
|
||||
val lower = part.lowercase()
|
||||
if (lower.length <= 2 || isAllowedWord(part)) continue
|
||||
// Heuristic: no vowels OR 3 repeated chars OR ends with unlikely double consonants
|
||||
val noVowel = lower.none { it in "aeiouy" }
|
||||
val triple = Regex("(.)\\1\\1").containsMatchIn(lower)
|
||||
val dblCons = Regex("[bcdfghjklmnpqrstvwxyz]{2}$").containsMatchIn(lower)
|
||||
var looksWrong = noVowel || triple || dblCons
|
||||
// Additional: low vowel ratio for length>=4
|
||||
if (!looksWrong && lower.length >= 4) {
|
||||
val vowels = lower.count { it in "aeiouy" }
|
||||
val ratio = if (lower.isNotEmpty()) vowels.toDouble() / lower.length else 1.0
|
||||
if (ratio < 0.25) looksWrong = true
|
||||
}
|
||||
// Additional: near-miss to a small base vocabulary (edit distance 1, or 2 for words >=6)
|
||||
if (!looksWrong) {
|
||||
for (bw in baseWords) {
|
||||
val d = editDistance(lower, bw)
|
||||
if (d == 1 || (d == 2 && lower.length >= 6)) { looksWrong = true; break }
|
||||
}
|
||||
}
|
||||
if (looksWrong) {
|
||||
val localStart = m.range.first + token.indexOf(part)
|
||||
val localEnd = localStart + part.length
|
||||
val abs = TextRange(hostRange.startOffset + localStart, hostRange.startOffset + localEnd)
|
||||
paintTypoAnnotation(file, holder, abs, part)
|
||||
painted++
|
||||
flagged++
|
||||
}
|
||||
}
|
||||
}
|
||||
log.info("LyngGrazieAnnotator.fallback(naive): fragment words=$seen, flagged=$flagged")
|
||||
}
|
||||
return painted
|
||||
}
|
||||
|
||||
private fun paintTypoAnnotation(file: PsiFile, holder: AnnotationHolder, range: TextRange, word: String) {
|
||||
val settings = LyngFormatterSettings.getInstance(file.project)
|
||||
val ab = holder.newAnnotation(HighlightSeverity.INFORMATION, "Possible typo")
|
||||
.range(range)
|
||||
applyTypoStyleIfRequested(file, ab)
|
||||
if (settings.offerLyngTypoQuickFixes) {
|
||||
// Offer lightweight fixes; for 243 provide Add-to-dictionary always
|
||||
ab.withFix(net.sergeych.lyng.idea.grazie.AddToLyngDictionaryFix(word))
|
||||
// Offer "Replace with…" candidates (top 7)
|
||||
val cands = suggestReplacements(file, word).take(7)
|
||||
for (c in cands) {
|
||||
ab.withFix(net.sergeych.lyng.idea.grazie.ReplaceWordFix(range, word, c))
|
||||
}
|
||||
}
|
||||
ab.create()
|
||||
}
|
||||
|
||||
private fun applyTypoStyleIfRequested(file: PsiFile, ab: com.intellij.lang.annotation.AnnotationBuilder) {
|
||||
val settings = LyngFormatterSettings.getInstance(file.project)
|
||||
if (!settings.showTyposWithGreenUnderline) return
|
||||
// Use the standard TYPO text attributes key used by the platform
|
||||
val TYPO: TextAttributesKey = TextAttributesKey.createTextAttributesKey("TYPO")
|
||||
try {
|
||||
ab.textAttributes(TYPO)
|
||||
} catch (_: Throwable) {
|
||||
// some IDEs may not allow setting attributes on INFORMATION; ignore gracefully
|
||||
}
|
||||
}
|
||||
|
||||
private fun suggestReplacements(file: PsiFile, word: String): List<String> {
|
||||
val lower = word.lowercase()
|
||||
val fromProject = collectProjectWords(file)
|
||||
val fromTech = TechDictionary.allWords()
|
||||
val fromEnglish = EnglishDictionary.allWords()
|
||||
// Merge with priority: project (p=0), tech (p=1), english (p=2)
|
||||
val all = LinkedHashSet<String>()
|
||||
all.addAll(fromProject)
|
||||
all.addAll(fromTech)
|
||||
all.addAll(fromEnglish)
|
||||
data class Cand(val w: String, val d: Int, val p: Int)
|
||||
val cands = ArrayList<Cand>(32)
|
||||
for (w in all) {
|
||||
if (w == lower) continue
|
||||
if (kotlin.math.abs(w.length - lower.length) > 2) continue
|
||||
val d = editDistance(lower, w)
|
||||
val p = when {
|
||||
w in fromProject -> 0
|
||||
w in fromTech -> 1
|
||||
else -> 2
|
||||
}
|
||||
cands += Cand(w, d, p)
|
||||
}
|
||||
cands.sortWith(compareBy<Cand> { it.d }.thenBy { it.p }.thenBy { it.w })
|
||||
// Return a larger pool so callers can choose desired display count
|
||||
return cands.take(16).map { it.w }
|
||||
}
|
||||
|
||||
private fun collectProjectWords(file: PsiFile): Set<String> {
|
||||
// Simple approach: use current file text; can be extended to project scanning later
|
||||
val text = file.viewProvider.document?.text ?: return emptySet()
|
||||
val out = LinkedHashSet<String>()
|
||||
val tokenRegex = Regex("[A-Za-z][A-Za-z0-9_']{2,}")
|
||||
for (m in tokenRegex.findAll(text)) {
|
||||
val parts = splitIdentifier(m.value)
|
||||
parts.forEach { out += it.lowercase() }
|
||||
}
|
||||
// Include learned words
|
||||
val settings = LyngFormatterSettings.getInstance(file.project)
|
||||
out.addAll(settings.learnedWords.map { it.lowercase() })
|
||||
return out
|
||||
}
|
||||
|
||||
private fun splitIdentifier(token: String): List<String> {
|
||||
// Split on underscores and camelCase boundaries
|
||||
val unders = token.split('_').filter { it.isNotBlank() }
|
||||
val out = mutableListOf<String>()
|
||||
val camelBoundary = Regex("(?<=[a-z])(?=[A-Z])")
|
||||
for (u in unders) out += u.split(camelBoundary).filter { it.isNotBlank() }
|
||||
return out
|
||||
}
|
||||
|
||||
private fun isAllowedWord(w: String): Boolean {
|
||||
val s = w.lowercase()
|
||||
return s in setOf(
|
||||
// common code words / language keywords to avoid noise
|
||||
"val","var","fun","class","interface","enum","type","import","package","return","if","else","when","while","for","try","catch","finally","true","false","null",
|
||||
"abstract","closed","override",
|
||||
// very common English words
|
||||
"the","and","or","not","with","from","into","this","that","file","found","count","name","value","object"
|
||||
)
|
||||
}
|
||||
|
||||
private fun editDistance(a: String, b: String): Int {
|
||||
if (a == b) return 0
|
||||
if (a.isEmpty()) return b.length
|
||||
if (b.isEmpty()) return a.length
|
||||
val dp = IntArray(b.length + 1) { it }
|
||||
for (i in 1..a.length) {
|
||||
var prev = dp[0]
|
||||
dp[0] = i
|
||||
for (j in 1..b.length) {
|
||||
val temp = dp[j]
|
||||
dp[j] = minOf(
|
||||
dp[j] + 1, // deletion
|
||||
dp[j - 1] + 1, // insertion
|
||||
prev + if (a[i - 1] == b[j - 1]) 0 else 1 // substitution
|
||||
)
|
||||
prev = temp
|
||||
}
|
||||
}
|
||||
return dp[b.length]
|
||||
}
|
||||
}
|
||||
@@ -1,139 +0,0 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
package net.sergeych.lyng.idea.grazie
|
||||
|
||||
import com.intellij.grazie.grammar.strategy.GrammarCheckingStrategy
|
||||
import com.intellij.grazie.grammar.strategy.GrammarCheckingStrategy.TextDomain
|
||||
import com.intellij.ide.plugins.PluginManagerCore
|
||||
import com.intellij.openapi.diagnostic.Logger
|
||||
import com.intellij.openapi.extensions.PluginId
|
||||
import com.intellij.openapi.util.TextRange
|
||||
import com.intellij.psi.PsiElement
|
||||
import net.sergeych.lyng.idea.highlight.LyngTokenTypes
|
||||
import net.sergeych.lyng.idea.settings.LyngFormatterSettings
|
||||
import net.sergeych.lyng.idea.spell.LyngSpellIndex
|
||||
|
||||
/**
|
||||
* Grazie/Natural Languages strategy for Lyng.
|
||||
*
|
||||
* - Comments: checked as natural language (TextDomain.COMMENTS)
|
||||
* - String literals: optionally checked (setting), skipping printf-like specifiers via stealth ranges (TextDomain.LITERALS)
|
||||
* - Identifiers (non-keywords): checked under TextDomain.CODE so "Process code" controls apply
|
||||
* - Keywords: skipped
|
||||
*/
|
||||
class LyngGrazieStrategy : GrammarCheckingStrategy {
|
||||
|
||||
private val log = Logger.getInstance(LyngGrazieStrategy::class.java)
|
||||
@Volatile private var loggedOnce = false
|
||||
@Volatile private var loggedFirstMatch = false
|
||||
private val seenTypes: MutableSet<String> = java.util.Collections.synchronizedSet(mutableSetOf())
|
||||
|
||||
private fun legacySpellcheckerInstalled(): Boolean =
|
||||
PluginManagerCore.isPluginInstalled(PluginId.getId("com.intellij.spellchecker"))
|
||||
|
||||
// Regex for printf-style specifiers: %[flags][width][.precision][length]type
|
||||
private val spec = Regex("%(?:[-+ #0]*(?:\\d+)?(?:\\.\\d+)?[a-zA-Z%])")
|
||||
|
||||
override fun isMyContextRoot(element: PsiElement): Boolean {
|
||||
val type = element.node?.elementType
|
||||
val settings = LyngFormatterSettings.getInstance(element.project)
|
||||
val legacyPresent = legacySpellcheckerInstalled()
|
||||
if (type != null && seenTypes.size < 10) {
|
||||
val name = type.toString()
|
||||
if (seenTypes.add(name)) {
|
||||
log.info("LyngGrazieStrategy: saw PSI type=$name")
|
||||
}
|
||||
}
|
||||
if (!loggedOnce) {
|
||||
loggedOnce = true
|
||||
log.info("LyngGrazieStrategy activated: legacyPresent=$legacyPresent, preferGrazieForCommentsAndLiterals=${settings.preferGrazieForCommentsAndLiterals}, spellCheckStringLiterals=${settings.spellCheckStringLiterals}, grazieChecksIdentifiers=${settings.grazieChecksIdentifiers}")
|
||||
}
|
||||
|
||||
val file = element.containingFile ?: return false
|
||||
val index = LyngSpellIndex.getUpToDate(file) ?: return false // Suspend until ready
|
||||
// To ensure Grazie asks TextExtractor for all leafs, accept any Lyng element once index is ready.
|
||||
// The extractor will decide per-range/domain what to actually provide.
|
||||
if (!loggedFirstMatch) {
|
||||
loggedFirstMatch = true
|
||||
log.info("LyngGrazieStrategy: enabling Grazie on all Lyng elements (index ready)")
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
override fun getContextRootTextDomain(root: PsiElement): TextDomain {
|
||||
val type = root.node?.elementType
|
||||
val settings = LyngFormatterSettings.getInstance(root.project)
|
||||
val file = root.containingFile
|
||||
val index = if (file != null) LyngSpellIndex.getUpToDate(file) else null
|
||||
val r = root.textRange
|
||||
|
||||
fun overlaps(list: List<TextRange>): Boolean = r != null && list.any { it.intersects(r) }
|
||||
|
||||
return when (type) {
|
||||
LyngTokenTypes.LINE_COMMENT, LyngTokenTypes.BLOCK_COMMENT -> TextDomain.COMMENTS
|
||||
LyngTokenTypes.STRING -> if (settings.grazieTreatLiteralsAsComments) TextDomain.COMMENTS else TextDomain.LITERALS
|
||||
LyngTokenTypes.IDENTIFIER -> {
|
||||
// For Grazie-only reliability in 243, route identifiers via COMMENTS when configured
|
||||
if (settings.grazieTreatIdentifiersAsComments && index != null && r != null && overlaps(index.identifiers))
|
||||
TextDomain.COMMENTS
|
||||
else TextDomain.PLAIN_TEXT
|
||||
}
|
||||
else -> TextDomain.PLAIN_TEXT
|
||||
}
|
||||
}
|
||||
|
||||
// Note: do not override getLanguageSupport to keep compatibility with 243 API
|
||||
|
||||
override fun getStealthyRanges(root: PsiElement, text: CharSequence): java.util.LinkedHashSet<IntRange> {
|
||||
val result = LinkedHashSet<IntRange>()
|
||||
val type = root.node?.elementType
|
||||
if (type == LyngTokenTypes.STRING) {
|
||||
if (!shouldCheckLiterals(root)) {
|
||||
// Hide the entire string when literals checking is disabled by settings
|
||||
result += (0 until text.length)
|
||||
return result
|
||||
}
|
||||
// Hide printf-like specifiers in strings
|
||||
val (start, end) = stripQuotesBounds(text)
|
||||
if (end > start) {
|
||||
val content = text.subSequence(start, end)
|
||||
for (m in spec.findAll(content)) {
|
||||
val ms = start + m.range.first
|
||||
val me = start + m.range.last
|
||||
result += (ms..me)
|
||||
}
|
||||
if (result.isNotEmpty()) {
|
||||
log.debug("LyngGrazieStrategy: hidden ${result.size} printf specifier ranges in string literal")
|
||||
}
|
||||
}
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
override fun isEnabledByDefault(): Boolean = true
|
||||
|
||||
private fun shouldCheckLiterals(root: PsiElement): Boolean =
|
||||
LyngFormatterSettings.getInstance(root.project).spellCheckStringLiterals
|
||||
|
||||
private fun stripQuotesBounds(text: CharSequence): Pair<Int, Int> {
|
||||
if (text.length < 2) return 0 to text.length
|
||||
val first = text.first()
|
||||
val last = text.last()
|
||||
return if ((first == '"' && last == '"') || (first == '\'' && last == '\''))
|
||||
1 to (text.length - 1) else (0 to text.length)
|
||||
}
|
||||
}
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
@@ -19,86 +19,29 @@ package net.sergeych.lyng.idea.grazie
|
||||
import com.intellij.grazie.text.TextContent
|
||||
import com.intellij.grazie.text.TextContent.TextDomain
|
||||
import com.intellij.grazie.text.TextExtractor
|
||||
import com.intellij.openapi.diagnostic.Logger
|
||||
import com.intellij.psi.PsiElement
|
||||
import net.sergeych.lyng.idea.highlight.LyngTokenTypes
|
||||
import net.sergeych.lyng.idea.settings.LyngFormatterSettings
|
||||
import net.sergeych.lyng.idea.spell.LyngSpellIndex
|
||||
import net.sergeych.lyng.idea.psi.LyngElementTypes
|
||||
|
||||
/**
|
||||
* Provides Grazie with extractable text for Lyng PSI elements.
|
||||
* We return text for identifiers, comments, and (optionally) string literals.
|
||||
* printf-like specifiers are filtered by the Grammar strategy via stealth ranges.
|
||||
* Simplified TextExtractor for Lyng.
|
||||
* Designates areas for Natural Languages (Grazie) to check.
|
||||
*/
|
||||
class LyngTextExtractor : TextExtractor() {
|
||||
private val log = Logger.getInstance(LyngTextExtractor::class.java)
|
||||
@Volatile private var loggedOnce = false
|
||||
private val seen: MutableSet<String> = java.util.Collections.synchronizedSet(mutableSetOf())
|
||||
|
||||
override fun buildTextContent(element: PsiElement, allowedDomains: Set<TextDomain>): TextContent? {
|
||||
val type = element.node?.elementType ?: return null
|
||||
if (!loggedOnce) {
|
||||
loggedOnce = true
|
||||
log.info("LyngTextExtractor active; allowedDomains=${allowedDomains.joinToString()}")
|
||||
}
|
||||
val settings = LyngFormatterSettings.getInstance(element.project)
|
||||
val file = element.containingFile
|
||||
val index = if (file != null) LyngSpellIndex.getUpToDate(file) else null
|
||||
val r = element.textRange
|
||||
|
||||
fun overlaps(list: List<com.intellij.openapi.util.TextRange>): Boolean = r != null && list.any { it.intersects(r) }
|
||||
|
||||
// Decide target domain by intersection with our MiniAst-driven index; prefer comments > strings > identifiers
|
||||
var domain: TextDomain? = null
|
||||
if (index != null && r != null) {
|
||||
if (overlaps(index.comments)) domain = TextDomain.COMMENTS
|
||||
else if (overlaps(index.strings) && settings.spellCheckStringLiterals) domain = TextDomain.LITERALS
|
||||
else if (overlaps(index.identifiers)) domain = if (settings.grazieTreatIdentifiersAsComments) TextDomain.COMMENTS else TextDomain.DOCUMENTATION
|
||||
} else {
|
||||
// Fallback to token type if index is not ready (rare timing), mostly for comments
|
||||
domain = when (type) {
|
||||
LyngTokenTypes.LINE_COMMENT, LyngTokenTypes.BLOCK_COMMENT -> TextDomain.COMMENTS
|
||||
else -> null
|
||||
}
|
||||
}
|
||||
if (domain == null) return null
|
||||
|
||||
// If literals aren't requested but fallback is enabled, route strings as COMMENTS
|
||||
if (domain == TextDomain.LITERALS && !allowedDomains.contains(TextDomain.LITERALS) && settings.grazieTreatLiteralsAsComments) {
|
||||
domain = TextDomain.COMMENTS
|
||||
}
|
||||
if (!allowedDomains.contains(domain)) {
|
||||
if (seen.add("deny-${domain.name}")) {
|
||||
log.info("LyngTextExtractor: domain ${domain.name} not in allowedDomains; skipping")
|
||||
}
|
||||
return null
|
||||
}
|
||||
return try {
|
||||
// Try common factory names across versions
|
||||
val methods = TextContent::class.java.methods.filter { it.name == "psiFragment" }
|
||||
val built: TextContent? = when {
|
||||
// Try psiFragment(PsiElement, TextDomain)
|
||||
methods.any { it.parameterCount == 2 && it.parameterTypes[0].name.contains("PsiElement") } -> {
|
||||
val m = methods.first { it.parameterCount == 2 && it.parameterTypes[0].name.contains("PsiElement") }
|
||||
@Suppress("UNCHECKED_CAST")
|
||||
(m.invoke(null, element, domain) as? TextContent)?.also {
|
||||
if (seen.add("ok-${domain.name}")) log.info("LyngTextExtractor: provided ${domain.name} for ${type} via psiFragment(element, domain)")
|
||||
}
|
||||
}
|
||||
// Try psiFragment(TextDomain, PsiElement)
|
||||
methods.any { it.parameterCount == 2 && it.parameterTypes[0].name.endsWith("TextDomain") } -> {
|
||||
val m = methods.first { it.parameterCount == 2 && it.parameterTypes[0].name.endsWith("TextDomain") }
|
||||
@Suppress("UNCHECKED_CAST")
|
||||
(m.invoke(null, domain, element) as? TextContent)?.also {
|
||||
if (seen.add("ok-${domain.name}")) log.info("LyngTextExtractor: provided ${domain.name} for ${type} via psiFragment(domain, element)")
|
||||
}
|
||||
}
|
||||
else -> null
|
||||
}
|
||||
built
|
||||
} catch (e: Throwable) {
|
||||
log.info("LyngTextExtractor: failed to build TextContent: ${e.javaClass.simpleName}: ${e.message}")
|
||||
null
|
||||
|
||||
val domain = when (type) {
|
||||
LyngTokenTypes.LINE_COMMENT, LyngTokenTypes.BLOCK_COMMENT -> TextDomain.COMMENTS
|
||||
LyngTokenTypes.STRING -> TextDomain.LITERALS
|
||||
LyngElementTypes.NAME_IDENTIFIER,
|
||||
LyngElementTypes.PARAMETER_NAME,
|
||||
LyngElementTypes.ENUM_CONSTANT_NAME -> TextDomain.COMMENTS
|
||||
else -> return null
|
||||
}
|
||||
|
||||
if (!allowedDomains.contains(domain)) return null
|
||||
|
||||
return TextContent.psiFragment(domain, element)
|
||||
}
|
||||
}
|
||||
@@ -1,86 +0,0 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
package net.sergeych.lyng.idea.grazie
|
||||
|
||||
import com.intellij.codeInsight.daemon.DaemonCodeAnalyzer
|
||||
import com.intellij.codeInsight.intention.IntentionAction
|
||||
import com.intellij.openapi.command.WriteCommandAction
|
||||
import com.intellij.openapi.editor.CaretModel
|
||||
import com.intellij.openapi.editor.Document
|
||||
import com.intellij.openapi.editor.Editor
|
||||
import com.intellij.openapi.project.Project
|
||||
import com.intellij.openapi.util.TextRange
|
||||
import com.intellij.psi.PsiFile
|
||||
|
||||
/**
|
||||
* Lightweight quick-fix to replace a misspelled word (subrange) with a suggested alternative.
|
||||
* Works without the legacy Spell Checker. The replacement is applied directly to the file text.
|
||||
*/
|
||||
class ReplaceWordFix(
|
||||
private val range: TextRange,
|
||||
private val original: String,
|
||||
private val replacementRaw: String
|
||||
) : IntentionAction {
|
||||
|
||||
override fun getText(): String = "Replace '$original' with '$replacementRaw'"
|
||||
override fun getFamilyName(): String = "Lyng Spelling"
|
||||
override fun isAvailable(project: Project, editor: Editor?, file: PsiFile?): Boolean =
|
||||
editor != null && file != null && range.startOffset in 0..range.endOffset
|
||||
|
||||
override fun startInWriteAction(): Boolean = true
|
||||
|
||||
override fun invoke(project: Project, editor: Editor?, file: PsiFile?) {
|
||||
if (editor == null) return
|
||||
val doc: Document = editor.document
|
||||
val safeRange = range.constrainTo(doc)
|
||||
val current = doc.getText(safeRange)
|
||||
// Preserve basic case style based on the original token
|
||||
val replacement = adaptCaseStyle(current, replacementRaw)
|
||||
WriteCommandAction.runWriteCommandAction(project, "Replace word", null, Runnable {
|
||||
doc.replaceString(safeRange.startOffset, safeRange.endOffset, replacement)
|
||||
}, file)
|
||||
// Move caret to end of replacement for convenience
|
||||
try {
|
||||
val caret: CaretModel = editor.caretModel
|
||||
caret.moveToOffset(safeRange.startOffset + replacement.length)
|
||||
} catch (_: Throwable) {}
|
||||
// Restart daemon to refresh highlights
|
||||
if (file != null) DaemonCodeAnalyzer.getInstance(project).restart(file)
|
||||
}
|
||||
|
||||
private fun TextRange.constrainTo(doc: Document): TextRange {
|
||||
val start = startOffset.coerceIn(0, doc.textLength)
|
||||
val end = endOffset.coerceIn(start, doc.textLength)
|
||||
return TextRange(start, end)
|
||||
}
|
||||
|
||||
private fun adaptCaseStyle(sample: String, suggestion: String): String {
|
||||
if (suggestion.isEmpty()) return suggestion
|
||||
return when {
|
||||
sample.all { it.isUpperCase() } -> suggestion.uppercase()
|
||||
// PascalCase / Capitalized single word
|
||||
sample.firstOrNull()?.isUpperCase() == true && sample.drop(1).any { it.isLowerCase() } ->
|
||||
suggestion.replaceFirstChar { if (it.isLowerCase()) it.titlecase() else it.toString() }
|
||||
// snake_case -> lower
|
||||
sample.contains('_') -> suggestion.lowercase()
|
||||
// camelCase -> lower first
|
||||
sample.firstOrNull()?.isLowerCase() == true && sample.any { it.isUpperCase() } ->
|
||||
suggestion.replaceFirstChar { it.lowercase() }
|
||||
else -> suggestion
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,77 +0,0 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
package net.sergeych.lyng.idea.grazie
|
||||
|
||||
import com.intellij.openapi.diagnostic.Logger
|
||||
import java.io.BufferedReader
|
||||
import java.io.InputStreamReader
|
||||
import java.util.zip.GZIPInputStream
|
||||
|
||||
/**
|
||||
* Lightweight technical/Lyng vocabulary dictionary.
|
||||
* Loaded from classpath resources; supports .txt and .txt.gz. Merged with EnglishDictionary.
|
||||
*/
|
||||
object TechDictionary {
|
||||
private val log = Logger.getInstance(TechDictionary::class.java)
|
||||
@Volatile private var loaded = false
|
||||
@Volatile private var words: Set<String> = emptySet()
|
||||
|
||||
private fun ensureLoaded() {
|
||||
if (loaded) return
|
||||
synchronized(this) {
|
||||
if (loaded) return
|
||||
val candidates = listOf(
|
||||
"/dictionaries/tech-lyng.txt.gz",
|
||||
"/dictionaries/tech-lyng.txt"
|
||||
)
|
||||
val merged = HashSet<String>(8_000)
|
||||
for (res in candidates) {
|
||||
try {
|
||||
val stream = javaClass.getResourceAsStream(res) ?: continue
|
||||
val reader = if (res.endsWith(".gz"))
|
||||
BufferedReader(InputStreamReader(GZIPInputStream(stream)))
|
||||
else
|
||||
BufferedReader(InputStreamReader(stream))
|
||||
var n = 0
|
||||
reader.useLines { seq -> seq.forEach { line ->
|
||||
val w = line.trim()
|
||||
if (w.isNotEmpty() && !w.startsWith("#")) { merged += w.lowercase(); n++ }
|
||||
} }
|
||||
log.info("TechDictionary: loaded $n words from $res (total=${merged.size})")
|
||||
} catch (t: Throwable) {
|
||||
log.info("TechDictionary: failed to load $res: ${t.javaClass.simpleName}: ${t.message}")
|
||||
}
|
||||
}
|
||||
if (merged.isEmpty()) {
|
||||
merged += setOf(
|
||||
// minimal Lyng/tech seeding to avoid empty dictionary
|
||||
"lyng","miniast","binder","printf","specifier","specifiers","regex","token","tokens",
|
||||
"identifier","identifiers","keyword","keywords","comment","comments","string","strings",
|
||||
"literal","literals","formatting","formatter","grazie","typo","typos","dictionary","dictionaries"
|
||||
)
|
||||
log.info("TechDictionary: using minimal built-in set (${merged.size})")
|
||||
}
|
||||
words = merged
|
||||
loaded = true
|
||||
}
|
||||
}
|
||||
|
||||
fun allWords(): Set<String> {
|
||||
ensureLoaded()
|
||||
return words
|
||||
}
|
||||
}
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
@@ -101,8 +101,9 @@ class LyngLexer : LexerBase() {
|
||||
return
|
||||
}
|
||||
|
||||
// String "..." with simple escape handling
|
||||
if (ch == '"') {
|
||||
// String "..." or '...' with simple escape handling
|
||||
if (ch == '"' || ch == '\'') {
|
||||
val quote = ch
|
||||
i++
|
||||
while (i < endOffset) {
|
||||
val c = buffer[i]
|
||||
@@ -110,7 +111,7 @@ class LyngLexer : LexerBase() {
|
||||
i += 2
|
||||
continue
|
||||
}
|
||||
if (c == '"') { i++; break }
|
||||
if (c == quote) { i++; break }
|
||||
i++
|
||||
}
|
||||
myTokenEnd = i
|
||||
|
||||
+2
-1
@@ -20,13 +20,14 @@ package net.sergeych.lyng.idea.navigation
|
||||
import com.intellij.codeInsight.navigation.actions.GotoDeclarationHandler
|
||||
import com.intellij.openapi.editor.Editor
|
||||
import com.intellij.psi.PsiElement
|
||||
import net.sergeych.lyng.idea.LyngLanguage
|
||||
|
||||
/**
|
||||
* Ensures Ctrl+B (Go to Definition) works on Lyng identifiers by resolving through LyngPsiReference.
|
||||
*/
|
||||
class LyngGotoDeclarationHandler : GotoDeclarationHandler {
|
||||
override fun getGotoDeclarationTargets(sourceElement: PsiElement?, offset: Int, editor: Editor?): Array<PsiElement>? {
|
||||
if (sourceElement == null) return null
|
||||
if (sourceElement == null || sourceElement.language != LyngLanguage) return null
|
||||
|
||||
val allTargets = mutableListOf<PsiElement>()
|
||||
|
||||
|
||||
@@ -38,16 +38,18 @@ class LyngPsiReference(element: PsiElement) : PsiPolyVariantReferenceBase<PsiEle
|
||||
|
||||
val mini = LyngAstManager.getMiniAst(file) ?: return emptyArray()
|
||||
val binding = LyngAstManager.getBinding(file)
|
||||
val imported = DocLookupUtils.canonicalImportedModules(mini, text).toSet()
|
||||
val currentPackage = getPackageName(file)
|
||||
val allowedPackages = if (currentPackage != null) imported + currentPackage else imported
|
||||
|
||||
// 1. Member resolution (obj.member)
|
||||
val dotPos = TextCtx.findDotLeft(text, offset)
|
||||
if (dotPos != null) {
|
||||
val imported = DocLookupUtils.canonicalImportedModules(mini, text)
|
||||
val receiverClass = DocLookupUtils.guessReceiverClassViaMini(mini, text, dotPos, imported, binding)
|
||||
?: DocLookupUtils.guessReceiverClass(text, dotPos, imported, mini)
|
||||
val receiverClass = DocLookupUtils.guessReceiverClassViaMini(mini, text, dotPos, imported.toList(), binding)
|
||||
?: DocLookupUtils.guessReceiverClass(text, dotPos, imported.toList(), mini)
|
||||
|
||||
if (receiverClass != null) {
|
||||
val resolved = DocLookupUtils.resolveMemberWithInheritance(imported, receiverClass, name, mini)
|
||||
val resolved = DocLookupUtils.resolveMemberWithInheritance(imported.toList(), receiverClass, name, mini)
|
||||
if (resolved != null) {
|
||||
val owner = resolved.first
|
||||
val member = resolved.second
|
||||
@@ -75,7 +77,7 @@ class LyngPsiReference(element: PsiElement) : PsiPolyVariantReferenceBase<PsiEle
|
||||
}
|
||||
// If we couldn't resolve exactly, we might still want to search globally but ONLY for members
|
||||
if (results.isEmpty()) {
|
||||
results.addAll(resolveGlobally(file.project, name, membersOnly = true))
|
||||
results.addAll(resolveGlobally(file.project, name, membersOnly = true, allowedPackages = allowedPackages))
|
||||
}
|
||||
} else {
|
||||
// 2. Local resolution via Binder
|
||||
@@ -94,7 +96,7 @@ class LyngPsiReference(element: PsiElement) : PsiPolyVariantReferenceBase<PsiEle
|
||||
// 3. Global project scan
|
||||
// Only search globally if we haven't found a strong local match
|
||||
if (results.isEmpty()) {
|
||||
results.addAll(resolveGlobally(file.project, name))
|
||||
results.addAll(resolveGlobally(file.project, name, allowedPackages = allowedPackages))
|
||||
}
|
||||
}
|
||||
|
||||
@@ -141,6 +143,16 @@ class LyngPsiReference(element: PsiElement) : PsiPolyVariantReferenceBase<PsiEle
|
||||
return null
|
||||
}
|
||||
|
||||
private fun getPackageName(file: PsiFile): String? {
|
||||
val mini = LyngAstManager.getMiniAst(file) ?: return null
|
||||
return try {
|
||||
val pkg = mini.range.start.source.extractPackageName()
|
||||
if (pkg.startsWith("lyng.")) pkg else "lyng.$pkg"
|
||||
} catch (e: Exception) {
|
||||
null
|
||||
}
|
||||
}
|
||||
|
||||
override fun resolve(): PsiElement? {
|
||||
val results = multiResolve(false)
|
||||
if (results.isEmpty()) return null
|
||||
@@ -154,13 +166,20 @@ class LyngPsiReference(element: PsiElement) : PsiPolyVariantReferenceBase<PsiEle
|
||||
return target
|
||||
}
|
||||
|
||||
private fun resolveGlobally(project: Project, name: String, membersOnly: Boolean = false): List<ResolveResult> {
|
||||
private fun resolveGlobally(project: Project, name: String, membersOnly: Boolean = false, allowedPackages: Set<String>? = null): List<ResolveResult> {
|
||||
val results = mutableListOf<ResolveResult>()
|
||||
val files = FilenameIndex.getAllFilesByExt(project, "lyng", GlobalSearchScope.projectScope(project))
|
||||
val psiManager = PsiManager.getInstance(project)
|
||||
|
||||
for (vFile in files) {
|
||||
val file = psiManager.findFile(vFile) ?: continue
|
||||
|
||||
// Filter by package if requested
|
||||
if (allowedPackages != null) {
|
||||
val pkg = getPackageName(file)
|
||||
if (pkg == null || pkg !in allowedPackages) continue
|
||||
}
|
||||
|
||||
val mini = LyngAstManager.getMiniAst(file) ?: continue
|
||||
val src = mini.range.start.source
|
||||
|
||||
|
||||
@@ -0,0 +1,27 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyng.idea.psi
|
||||
|
||||
import com.intellij.psi.tree.IElementType
|
||||
import net.sergeych.lyng.idea.LyngLanguage
|
||||
|
||||
object LyngElementTypes {
|
||||
val NAME_IDENTIFIER = IElementType("NAME_IDENTIFIER", LyngLanguage)
|
||||
val PARAMETER_NAME = IElementType("PARAMETER_NAME", LyngLanguage)
|
||||
val ENUM_CONSTANT_NAME = IElementType("ENUM_CONSTANT_NAME", LyngLanguage)
|
||||
}
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
@@ -45,7 +45,68 @@ class LyngParserDefinition : ParserDefinition {
|
||||
|
||||
override fun createParser(project: Project?): PsiParser = PsiParser { root, builder ->
|
||||
val mark: PsiBuilder.Marker = builder.mark()
|
||||
while (!builder.eof()) builder.advanceLexer()
|
||||
var lastKeyword: String? = null
|
||||
var inEnum = false
|
||||
var inParams = false
|
||||
var parenDepth = 0
|
||||
var braceDepth = 0
|
||||
|
||||
while (!builder.eof()) {
|
||||
val type = builder.tokenType
|
||||
val text = builder.tokenText
|
||||
|
||||
when (type) {
|
||||
LyngTokenTypes.KEYWORD -> {
|
||||
lastKeyword = text
|
||||
if (text == "enum") inEnum = true
|
||||
}
|
||||
LyngTokenTypes.PUNCT -> {
|
||||
if (text == "(") {
|
||||
parenDepth++
|
||||
if (lastKeyword == "fun" || lastKeyword == "constructor" || lastKeyword == "init") inParams = true
|
||||
} else if (text == ")") {
|
||||
parenDepth--
|
||||
if (parenDepth == 0) inParams = false
|
||||
} else if (text == "{") {
|
||||
braceDepth++
|
||||
} else if (text == "}") {
|
||||
braceDepth--
|
||||
if (braceDepth == 0) inEnum = false
|
||||
}
|
||||
if (text != ".") lastKeyword = null
|
||||
}
|
||||
LyngTokenTypes.IDENTIFIER -> {
|
||||
val m = builder.mark()
|
||||
builder.advanceLexer()
|
||||
val nextType = builder.tokenType
|
||||
val isQualified = nextType == LyngTokenTypes.PUNCT && builder.tokenText == "."
|
||||
|
||||
if (!isQualified) {
|
||||
when {
|
||||
lastKeyword in setOf("fun", "val", "var", "class", "enum", "object", "interface", "type", "property") -> {
|
||||
m.done(LyngElementTypes.NAME_IDENTIFIER)
|
||||
}
|
||||
inParams && parenDepth > 0 -> {
|
||||
m.done(LyngElementTypes.PARAMETER_NAME)
|
||||
}
|
||||
inEnum && braceDepth > 0 && parenDepth == 0 -> {
|
||||
m.done(LyngElementTypes.ENUM_CONSTANT_NAME)
|
||||
}
|
||||
else -> m.drop()
|
||||
}
|
||||
} else {
|
||||
m.drop()
|
||||
}
|
||||
lastKeyword = null
|
||||
continue
|
||||
}
|
||||
LyngTokenTypes.WHITESPACE, LyngTokenTypes.LINE_COMMENT, LyngTokenTypes.BLOCK_COMMENT -> {
|
||||
// keep lastKeyword
|
||||
}
|
||||
else -> lastKeyword = null
|
||||
}
|
||||
builder.advanceLexer()
|
||||
}
|
||||
mark.done(root)
|
||||
builder.treeBuilt
|
||||
}
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
@@ -32,24 +32,6 @@ class LyngFormatterSettings(private val project: Project) : PersistentStateCompo
|
||||
var reindentClosedBlockOnEnter: Boolean = true,
|
||||
var reindentPastedBlocks: Boolean = true,
|
||||
var normalizeBlockCommentIndent: Boolean = false,
|
||||
var spellCheckStringLiterals: Boolean = true,
|
||||
// When Grazie/Natural Languages is present, prefer it for comments and literals (avoid legacy duplicates)
|
||||
var preferGrazieForCommentsAndLiterals: Boolean = true,
|
||||
// When Grazie is available, also check identifiers via Grazie.
|
||||
// Default OFF because Grazie typically doesn't flag code identifiers; legacy Spellchecker is better for code.
|
||||
var grazieChecksIdentifiers: Boolean = false,
|
||||
// Grazie-only fallback: treat identifiers as comments domain so Grazie applies spelling rules
|
||||
var grazieTreatIdentifiersAsComments: Boolean = true,
|
||||
// Grazie-only fallback: treat string literals as comments domain when LITERALS domain is not requested
|
||||
var grazieTreatLiteralsAsComments: Boolean = true,
|
||||
// Debug helper: show the exact ranges we feed to Grazie/legacy as weak warnings
|
||||
var debugShowSpellFeed: Boolean = false,
|
||||
// Visuals: render Lyng typos using the standard Typo green underline styling
|
||||
var showTyposWithGreenUnderline: Boolean = true,
|
||||
// Enable lightweight quick-fixes (Replace..., Add to dictionary) without legacy Spell Checker
|
||||
var offerLyngTypoQuickFixes: Boolean = true,
|
||||
// Per-project learned words (do not flag again)
|
||||
var learnedWords: MutableSet<String> = mutableSetOf(),
|
||||
// Experimental: enable Lyng autocompletion (can be disabled if needed)
|
||||
var enableLyngCompletionExperimental: Boolean = true,
|
||||
)
|
||||
@@ -82,42 +64,6 @@ class LyngFormatterSettings(private val project: Project) : PersistentStateCompo
|
||||
get() = myState.normalizeBlockCommentIndent
|
||||
set(value) { myState.normalizeBlockCommentIndent = value }
|
||||
|
||||
var spellCheckStringLiterals: Boolean
|
||||
get() = myState.spellCheckStringLiterals
|
||||
set(value) { myState.spellCheckStringLiterals = value }
|
||||
|
||||
var preferGrazieForCommentsAndLiterals: Boolean
|
||||
get() = myState.preferGrazieForCommentsAndLiterals
|
||||
set(value) { myState.preferGrazieForCommentsAndLiterals = value }
|
||||
|
||||
var grazieChecksIdentifiers: Boolean
|
||||
get() = myState.grazieChecksIdentifiers
|
||||
set(value) { myState.grazieChecksIdentifiers = value }
|
||||
|
||||
var grazieTreatIdentifiersAsComments: Boolean
|
||||
get() = myState.grazieTreatIdentifiersAsComments
|
||||
set(value) { myState.grazieTreatIdentifiersAsComments = value }
|
||||
|
||||
var grazieTreatLiteralsAsComments: Boolean
|
||||
get() = myState.grazieTreatLiteralsAsComments
|
||||
set(value) { myState.grazieTreatLiteralsAsComments = value }
|
||||
|
||||
var debugShowSpellFeed: Boolean
|
||||
get() = myState.debugShowSpellFeed
|
||||
set(value) { myState.debugShowSpellFeed = value }
|
||||
|
||||
var showTyposWithGreenUnderline: Boolean
|
||||
get() = myState.showTyposWithGreenUnderline
|
||||
set(value) { myState.showTyposWithGreenUnderline = value }
|
||||
|
||||
var offerLyngTypoQuickFixes: Boolean
|
||||
get() = myState.offerLyngTypoQuickFixes
|
||||
set(value) { myState.offerLyngTypoQuickFixes = value }
|
||||
|
||||
var learnedWords: MutableSet<String>
|
||||
get() = myState.learnedWords
|
||||
set(value) { myState.learnedWords = value }
|
||||
|
||||
var enableLyngCompletionExperimental: Boolean
|
||||
get() = myState.enableLyngCompletionExperimental
|
||||
set(value) { myState.enableLyngCompletionExperimental = value }
|
||||
|
||||
+1
-56
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
@@ -30,14 +30,6 @@ class LyngFormatterSettingsConfigurable(private val project: Project) : Configur
|
||||
private var reindentClosedBlockCb: JCheckBox? = null
|
||||
private var reindentPasteCb: JCheckBox? = null
|
||||
private var normalizeBlockCommentIndentCb: JCheckBox? = null
|
||||
private var spellCheckLiteralsCb: JCheckBox? = null
|
||||
private var preferGrazieCommentsLiteralsCb: JCheckBox? = null
|
||||
private var grazieChecksIdentifiersCb: JCheckBox? = null
|
||||
private var grazieIdsAsCommentsCb: JCheckBox? = null
|
||||
private var grazieLiteralsAsCommentsCb: JCheckBox? = null
|
||||
private var debugShowSpellFeedCb: JCheckBox? = null
|
||||
private var showTyposGreenCb: JCheckBox? = null
|
||||
private var offerQuickFixesCb: JCheckBox? = null
|
||||
private var enableCompletionCb: JCheckBox? = null
|
||||
|
||||
override fun getDisplayName(): String = "Lyng Formatter"
|
||||
@@ -50,14 +42,6 @@ class LyngFormatterSettingsConfigurable(private val project: Project) : Configur
|
||||
reindentClosedBlockCb = JCheckBox("Reindent enclosed block on Enter after '}'")
|
||||
reindentPasteCb = JCheckBox("Reindent pasted blocks (align pasted code to current indent)")
|
||||
normalizeBlockCommentIndentCb = JCheckBox("Normalize block comment indentation [experimental]")
|
||||
spellCheckLiteralsCb = JCheckBox("Spell check string literals (skip % specifiers like %s, %d, %-12s)")
|
||||
preferGrazieCommentsLiteralsCb = JCheckBox("Prefer Natural Languages/Grazie for comments and string literals (avoid duplicates)")
|
||||
grazieChecksIdentifiersCb = JCheckBox("Check identifiers via Natural Languages/Grazie when available")
|
||||
grazieIdsAsCommentsCb = JCheckBox("Natural Languages/Grazie: treat identifiers as comments (forces spelling checks in 2024.3)")
|
||||
grazieLiteralsAsCommentsCb = JCheckBox("Natural Languages/Grazie: treat string literals as comments when literals are not processed")
|
||||
debugShowSpellFeedCb = JCheckBox("Debug: show spell-feed ranges (weak warnings)")
|
||||
showTyposGreenCb = JCheckBox("Show Lyng typos with green underline (TYPO styling)")
|
||||
offerQuickFixesCb = JCheckBox("Offer Lyng typo quick fixes (Replace…, Add to dictionary) without Spell Checker")
|
||||
enableCompletionCb = JCheckBox("Enable Lyng autocompletion (experimental)")
|
||||
|
||||
// Tooltips / short help
|
||||
@@ -66,27 +50,12 @@ class LyngFormatterSettingsConfigurable(private val project: Project) : Configur
|
||||
reindentClosedBlockCb?.toolTipText = "On Enter after a closing '}', reindent the just-closed {…} block using formatter rules."
|
||||
reindentPasteCb?.toolTipText = "When caret is in leading whitespace, reindent the pasted text and align it to the caret's indent."
|
||||
normalizeBlockCommentIndentCb?.toolTipText = "Experimental: normalize indentation inside /* … */ comments (code is not modified)."
|
||||
preferGrazieCommentsLiteralsCb?.toolTipText = "When ON and Natural Languages/Grazie is installed, comments and string literals are checked by Grazie. Turn OFF to force legacy Spellchecker to check them."
|
||||
grazieChecksIdentifiersCb?.toolTipText = "When ON and Natural Languages/Grazie is installed, identifiers (non-keywords) are checked by Grazie too."
|
||||
grazieIdsAsCommentsCb?.toolTipText = "Grazie-only fallback: route identifiers as COMMENTS domain so Grazie applies spelling in 2024.3."
|
||||
grazieLiteralsAsCommentsCb?.toolTipText = "Grazie-only fallback: when Grammar doesn't process literals, route strings as COMMENTS so they are checked."
|
||||
debugShowSpellFeedCb?.toolTipText = "Show the exact ranges we feed to spellcheckers (ids/comments/strings) as weak warnings."
|
||||
showTyposGreenCb?.toolTipText = "Render Lyng typos using the platform's green TYPO underline instead of generic warnings."
|
||||
offerQuickFixesCb?.toolTipText = "Provide lightweight Replace… and Add to dictionary quick-fixes without requiring the legacy Spell Checker."
|
||||
enableCompletionCb?.toolTipText = "Turn on/off the lightweight Lyng code completion (BASIC)."
|
||||
p.add(spacingCb)
|
||||
p.add(wrappingCb)
|
||||
p.add(reindentClosedBlockCb)
|
||||
p.add(reindentPasteCb)
|
||||
p.add(normalizeBlockCommentIndentCb)
|
||||
p.add(spellCheckLiteralsCb)
|
||||
p.add(preferGrazieCommentsLiteralsCb)
|
||||
p.add(grazieChecksIdentifiersCb)
|
||||
p.add(grazieIdsAsCommentsCb)
|
||||
p.add(grazieLiteralsAsCommentsCb)
|
||||
p.add(debugShowSpellFeedCb)
|
||||
p.add(showTyposGreenCb)
|
||||
p.add(offerQuickFixesCb)
|
||||
p.add(enableCompletionCb)
|
||||
panel = p
|
||||
reset()
|
||||
@@ -100,14 +69,6 @@ class LyngFormatterSettingsConfigurable(private val project: Project) : Configur
|
||||
reindentClosedBlockCb?.isSelected != s.reindentClosedBlockOnEnter ||
|
||||
reindentPasteCb?.isSelected != s.reindentPastedBlocks ||
|
||||
normalizeBlockCommentIndentCb?.isSelected != s.normalizeBlockCommentIndent ||
|
||||
spellCheckLiteralsCb?.isSelected != s.spellCheckStringLiterals ||
|
||||
preferGrazieCommentsLiteralsCb?.isSelected != s.preferGrazieForCommentsAndLiterals ||
|
||||
grazieChecksIdentifiersCb?.isSelected != s.grazieChecksIdentifiers ||
|
||||
grazieIdsAsCommentsCb?.isSelected != s.grazieTreatIdentifiersAsComments ||
|
||||
grazieLiteralsAsCommentsCb?.isSelected != s.grazieTreatLiteralsAsComments ||
|
||||
debugShowSpellFeedCb?.isSelected != s.debugShowSpellFeed ||
|
||||
showTyposGreenCb?.isSelected != s.showTyposWithGreenUnderline ||
|
||||
offerQuickFixesCb?.isSelected != s.offerLyngTypoQuickFixes ||
|
||||
enableCompletionCb?.isSelected != s.enableLyngCompletionExperimental
|
||||
}
|
||||
|
||||
@@ -118,14 +79,6 @@ class LyngFormatterSettingsConfigurable(private val project: Project) : Configur
|
||||
s.reindentClosedBlockOnEnter = reindentClosedBlockCb?.isSelected == true
|
||||
s.reindentPastedBlocks = reindentPasteCb?.isSelected == true
|
||||
s.normalizeBlockCommentIndent = normalizeBlockCommentIndentCb?.isSelected == true
|
||||
s.spellCheckStringLiterals = spellCheckLiteralsCb?.isSelected == true
|
||||
s.preferGrazieForCommentsAndLiterals = preferGrazieCommentsLiteralsCb?.isSelected == true
|
||||
s.grazieChecksIdentifiers = grazieChecksIdentifiersCb?.isSelected == true
|
||||
s.grazieTreatIdentifiersAsComments = grazieIdsAsCommentsCb?.isSelected == true
|
||||
s.grazieTreatLiteralsAsComments = grazieLiteralsAsCommentsCb?.isSelected == true
|
||||
s.debugShowSpellFeed = debugShowSpellFeedCb?.isSelected == true
|
||||
s.showTyposWithGreenUnderline = showTyposGreenCb?.isSelected == true
|
||||
s.offerLyngTypoQuickFixes = offerQuickFixesCb?.isSelected == true
|
||||
s.enableLyngCompletionExperimental = enableCompletionCb?.isSelected == true
|
||||
}
|
||||
|
||||
@@ -136,14 +89,6 @@ class LyngFormatterSettingsConfigurable(private val project: Project) : Configur
|
||||
reindentClosedBlockCb?.isSelected = s.reindentClosedBlockOnEnter
|
||||
reindentPasteCb?.isSelected = s.reindentPastedBlocks
|
||||
normalizeBlockCommentIndentCb?.isSelected = s.normalizeBlockCommentIndent
|
||||
spellCheckLiteralsCb?.isSelected = s.spellCheckStringLiterals
|
||||
preferGrazieCommentsLiteralsCb?.isSelected = s.preferGrazieForCommentsAndLiterals
|
||||
grazieChecksIdentifiersCb?.isSelected = s.grazieChecksIdentifiers
|
||||
grazieIdsAsCommentsCb?.isSelected = s.grazieTreatIdentifiersAsComments
|
||||
grazieLiteralsAsCommentsCb?.isSelected = s.grazieTreatLiteralsAsComments
|
||||
debugShowSpellFeedCb?.isSelected = s.debugShowSpellFeed
|
||||
showTyposGreenCb?.isSelected = s.showTyposWithGreenUnderline
|
||||
offerQuickFixesCb?.isSelected = s.offerLyngTypoQuickFixes
|
||||
enableCompletionCb?.isSelected = s.enableLyngCompletionExperimental
|
||||
}
|
||||
}
|
||||
@@ -1,50 +0,0 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
package net.sergeych.lyng.idea.spell
|
||||
|
||||
import com.intellij.openapi.diagnostic.Logger
|
||||
import com.intellij.openapi.util.Key
|
||||
import com.intellij.openapi.util.TextRange
|
||||
import com.intellij.psi.PsiFile
|
||||
|
||||
/**
|
||||
* Per-file cached spellcheck index built from MiniAst-based highlighting and the lynglib highlighter.
|
||||
* It exposes identifier, comment, and string literal ranges. Strategies should suspend until data is ready.
|
||||
*/
|
||||
object LyngSpellIndex {
|
||||
private val LOG = Logger.getInstance(LyngSpellIndex::class.java)
|
||||
|
||||
data class Data(
|
||||
val modStamp: Long,
|
||||
val identifiers: List<TextRange>,
|
||||
val comments: List<TextRange>,
|
||||
val strings: List<TextRange>,
|
||||
)
|
||||
|
||||
private val KEY: Key<Data> = Key.create("LYNG_SPELL_INDEX")
|
||||
|
||||
fun getUpToDate(file: PsiFile): Data? {
|
||||
val doc = file.viewProvider.document ?: return null
|
||||
val d = file.getUserData(KEY) ?: return null
|
||||
return if (d.modStamp == doc.modificationStamp) d else null
|
||||
}
|
||||
|
||||
fun store(file: PsiFile, data: Data) {
|
||||
file.putUserData(KEY, data)
|
||||
LOG.info("LyngSpellIndex built: ids=${data.identifiers.size}, comments=${data.comments.size}, strings=${data.strings.size}")
|
||||
}
|
||||
}
|
||||
+14
-128
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
@@ -16,140 +16,26 @@
|
||||
*/
|
||||
package net.sergeych.lyng.idea.spell
|
||||
|
||||
// Avoid Tokenizers helper to keep compatibility; implement our own tokenizers
|
||||
import com.intellij.ide.plugins.PluginManagerCore
|
||||
import com.intellij.openapi.diagnostic.Logger
|
||||
import com.intellij.openapi.extensions.PluginId
|
||||
import com.intellij.openapi.util.TextRange
|
||||
import com.intellij.psi.PsiElement
|
||||
import com.intellij.spellchecker.inspections.PlainTextSplitter
|
||||
import com.intellij.spellchecker.tokenizer.SpellcheckingStrategy
|
||||
import com.intellij.spellchecker.tokenizer.TokenConsumer
|
||||
import com.intellij.spellchecker.tokenizer.Tokenizer
|
||||
import net.sergeych.lyng.idea.settings.LyngFormatterSettings
|
||||
import net.sergeych.lyng.idea.highlight.LyngTokenTypes
|
||||
import net.sergeych.lyng.idea.psi.LyngElementTypes
|
||||
|
||||
/**
|
||||
* Spellchecking strategy for Lyng:
|
||||
* - Identifiers: checked as identifiers
|
||||
* - Comments: checked as plain text
|
||||
* - Keywords: skipped
|
||||
* - String literals: optional (controlled by settings), and we exclude printf-style format specifiers like
|
||||
* %s, %d, %-12s, %0.2f, etc.
|
||||
* Standard IntelliJ spellchecking strategy for Lyng.
|
||||
* Uses the simplified PSI structure to identify declarations.
|
||||
*/
|
||||
class LyngSpellcheckingStrategy : SpellcheckingStrategy() {
|
||||
|
||||
private val log = Logger.getInstance(LyngSpellcheckingStrategy::class.java)
|
||||
@Volatile private var loggedOnce = false
|
||||
|
||||
private fun grazieInstalled(): Boolean {
|
||||
// Support both historical and bundled IDs
|
||||
return PluginManagerCore.isPluginInstalled(PluginId.getId("com.intellij.grazie")) ||
|
||||
PluginManagerCore.isPluginInstalled(PluginId.getId("tanvd.grazi"))
|
||||
}
|
||||
|
||||
private fun grazieApiAvailable(): Boolean = try {
|
||||
// If this class is absent (as in IC-243), third-party plugins can't run Grazie programmatically
|
||||
Class.forName("com.intellij.grazie.grammar.GrammarChecker")
|
||||
true
|
||||
} catch (_: Throwable) { false }
|
||||
|
||||
override fun getTokenizer(element: PsiElement): Tokenizer<*> {
|
||||
val hasGrazie = grazieInstalled()
|
||||
val hasGrazieApi = grazieApiAvailable()
|
||||
val settings = LyngFormatterSettings.getInstance(element.project)
|
||||
if (!loggedOnce) {
|
||||
loggedOnce = true
|
||||
log.info("LyngSpellcheckingStrategy activated: hasGrazie=$hasGrazie, grazieApi=$hasGrazieApi, preferGrazieForCommentsAndLiterals=${settings.preferGrazieForCommentsAndLiterals}, spellCheckStringLiterals=${settings.spellCheckStringLiterals}, grazieChecksIdentifiers=${settings.grazieChecksIdentifiers}")
|
||||
}
|
||||
|
||||
val file = element.containingFile ?: return EMPTY_TOKENIZER
|
||||
val index = LyngSpellIndex.getUpToDate(file) ?: run {
|
||||
// Suspend legacy spellcheck until MiniAst-based index is ready
|
||||
return EMPTY_TOKENIZER
|
||||
}
|
||||
val elRange = element.textRange ?: return EMPTY_TOKENIZER
|
||||
|
||||
fun overlaps(list: List<TextRange>) = list.any { it.intersects(elRange) }
|
||||
|
||||
// Decide responsibility per settings
|
||||
// If Grazie is present but its public API is not available (IC-243), do NOT delegate to it.
|
||||
val preferGrazie = hasGrazie && hasGrazieApi && settings.preferGrazieForCommentsAndLiterals
|
||||
val grazieIds = hasGrazie && hasGrazieApi && settings.grazieChecksIdentifiers
|
||||
|
||||
// Identifiers: only if range is within identifiers index and not delegated to Grazie
|
||||
if (overlaps(index.identifiers) && !grazieIds) return IDENTIFIER_TOKENIZER
|
||||
|
||||
// Comments: only if not delegated to Grazie and overlapping indexed comments
|
||||
if (!preferGrazie && overlaps(index.comments)) return COMMENT_TEXT_TOKENIZER
|
||||
|
||||
// Strings: only if not delegated to Grazie, literals checking enabled, and overlapping indexed strings
|
||||
if (!preferGrazie && settings.spellCheckStringLiterals && overlaps(index.strings)) return STRING_WITH_PRINTF_EXCLUDES
|
||||
|
||||
return EMPTY_TOKENIZER
|
||||
}
|
||||
|
||||
private object EMPTY_TOKENIZER : Tokenizer<PsiElement>() {
|
||||
override fun tokenize(element: PsiElement, consumer: TokenConsumer) {}
|
||||
}
|
||||
|
||||
private object IDENTIFIER_TOKENIZER : Tokenizer<PsiElement>() {
|
||||
private val splitter = PlainTextSplitter.getInstance()
|
||||
override fun tokenize(element: PsiElement, consumer: TokenConsumer) {
|
||||
val text = element.text
|
||||
if (text.isNullOrEmpty()) return
|
||||
consumer.consumeToken(element, text, false, 0, TextRange(0, text.length), splitter)
|
||||
}
|
||||
}
|
||||
|
||||
private object COMMENT_TEXT_TOKENIZER : Tokenizer<PsiElement>() {
|
||||
private val splitter = PlainTextSplitter.getInstance()
|
||||
override fun tokenize(element: PsiElement, consumer: TokenConsumer) {
|
||||
val text = element.text
|
||||
if (text.isNullOrEmpty()) return
|
||||
consumer.consumeToken(element, text, false, 0, TextRange(0, text.length), splitter)
|
||||
}
|
||||
}
|
||||
|
||||
private object STRING_WITH_PRINTF_EXCLUDES : Tokenizer<PsiElement>() {
|
||||
private val splitter = PlainTextSplitter.getInstance()
|
||||
|
||||
// Regex for printf-style specifiers: %[flags][width][.precision][length]type
|
||||
// This is intentionally permissive to skip common cases like %s, %d, %-12s, %08x, %.2f, %%
|
||||
private val SPEC = Regex("%(?:[-+ #0]*(?:\\d+)?(?:\\.\\d+)?[a-zA-Z%])")
|
||||
|
||||
override fun tokenize(element: PsiElement, consumer: TokenConsumer) {
|
||||
// Check project settings whether literals should be spell-checked
|
||||
val settings = LyngFormatterSettings.getInstance(element.project)
|
||||
if (!settings.spellCheckStringLiterals) return
|
||||
|
||||
val text = element.text
|
||||
if (text.isEmpty()) return
|
||||
|
||||
// Try to strip surrounding quotes (simple lexer token for Lyng strings)
|
||||
var startOffsetInElement = 0
|
||||
var endOffsetInElement = text.length
|
||||
if (text.length >= 2 && (text.first() == '"' && text.last() == '"' || text.first() == '\'' && text.last() == '\'')) {
|
||||
startOffsetInElement = 1
|
||||
endOffsetInElement = text.length - 1
|
||||
}
|
||||
if (endOffsetInElement <= startOffsetInElement) return
|
||||
|
||||
val content = text.substring(startOffsetInElement, endOffsetInElement)
|
||||
|
||||
var last = 0
|
||||
for (m in SPEC.findAll(content)) {
|
||||
val ms = m.range.first
|
||||
val me = m.range.last + 1
|
||||
if (ms > last) {
|
||||
val range = TextRange(startOffsetInElement + last, startOffsetInElement + ms)
|
||||
consumer.consumeToken(element, text, false, 0, range, splitter)
|
||||
}
|
||||
last = me
|
||||
}
|
||||
if (last < content.length) {
|
||||
val range = TextRange(startOffsetInElement + last, startOffsetInElement + content.length)
|
||||
consumer.consumeToken(element, text, false, 0, range, splitter)
|
||||
}
|
||||
override fun getTokenizer(element: PsiElement?): Tokenizer<*> {
|
||||
val type = element?.node?.elementType
|
||||
return when (type) {
|
||||
LyngTokenTypes.LINE_COMMENT, LyngTokenTypes.BLOCK_COMMENT -> TEXT_TOKENIZER
|
||||
LyngTokenTypes.STRING -> TEXT_TOKENIZER
|
||||
LyngElementTypes.NAME_IDENTIFIER,
|
||||
LyngElementTypes.PARAMETER_NAME,
|
||||
LyngElementTypes.ENUM_CONSTANT_NAME -> TEXT_TOKENIZER
|
||||
else -> super.getTokenizer(element)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,3 +1,20 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* Ensure external/bundled docs are registered in BuiltinDocRegistry
|
||||
* so completion/quickdoc can resolve things like lyng.io.fs.Path.
|
||||
@@ -6,6 +23,7 @@ package net.sergeych.lyng.idea.util
|
||||
|
||||
import com.intellij.openapi.diagnostic.Logger
|
||||
import net.sergeych.lyng.idea.docs.FsDocsFallback
|
||||
import net.sergeych.lyng.idea.docs.ProcessDocsFallback
|
||||
|
||||
object DocsBootstrap {
|
||||
private val log = Logger.getInstance(DocsBootstrap::class.java)
|
||||
@@ -20,20 +38,32 @@ object DocsBootstrap {
|
||||
}
|
||||
}
|
||||
|
||||
private fun tryLoadExternal(): Boolean = try {
|
||||
val cls = Class.forName("net.sergeych.lyngio.docs.FsBuiltinDocs")
|
||||
val m = cls.getMethod("ensure")
|
||||
m.invoke(null)
|
||||
log.info("[LYNG_DEBUG] DocsBootstrap: external docs loaded: net.sergeych.lyngio.docs.FsBuiltinDocs.ensure() OK")
|
||||
true
|
||||
} catch (_: Throwable) {
|
||||
false
|
||||
private fun tryLoadExternal(): Boolean {
|
||||
var anyLoaded = false
|
||||
try {
|
||||
val cls = Class.forName("net.sergeych.lyngio.docs.FsBuiltinDocs")
|
||||
val m = cls.getMethod("ensure")
|
||||
m.invoke(null)
|
||||
log.info("[LYNG_DEBUG] DocsBootstrap: external docs loaded: net.sergeych.lyngio.docs.FsBuiltinDocs.ensure() OK")
|
||||
anyLoaded = true
|
||||
} catch (_: Throwable) {}
|
||||
|
||||
try {
|
||||
val cls = Class.forName("net.sergeych.lyngio.docs.ProcessBuiltinDocs")
|
||||
val m = cls.getMethod("ensure")
|
||||
m.invoke(null)
|
||||
log.info("[LYNG_DEBUG] DocsBootstrap: external docs loaded: net.sergeych.lyngio.docs.ProcessBuiltinDocs.ensure() OK")
|
||||
anyLoaded = true
|
||||
} catch (_: Throwable) {}
|
||||
return anyLoaded
|
||||
}
|
||||
|
||||
private fun trySeedFallback(): Boolean = try {
|
||||
val seeded = FsDocsFallback.ensureOnce()
|
||||
val seededFs = FsDocsFallback.ensureOnce()
|
||||
val seededProcess = ProcessDocsFallback.ensureOnce()
|
||||
val seeded = seededFs || seededProcess
|
||||
if (seeded) {
|
||||
log.info("[LYNG_DEBUG] DocsBootstrap: external docs not found; seeded plugin fallback for lyng.io.fs")
|
||||
log.info("[LYNG_DEBUG] DocsBootstrap: external docs not found; seeded plugin fallback for lyng.io.fs/process")
|
||||
} else {
|
||||
log.info("[LYNG_DEBUG] DocsBootstrap: external docs not found; no fallback seeded")
|
||||
}
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
<!--
|
||||
~ Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
~ Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
~
|
||||
~ Licensed under the Apache License, Version 2.0 (the "License");
|
||||
~ you may not use this file except in compliance with the License.
|
||||
@@ -20,8 +20,6 @@
|
||||
-->
|
||||
<idea-plugin>
|
||||
<extensions defaultExtensionNs="com.intellij">
|
||||
<grazie.grammar.strategy language="Lyng"
|
||||
implementationClass="net.sergeych.lyng.idea.grazie.LyngGrazieStrategy"/>
|
||||
<!-- Provide text extraction for Lyng PSI so Grazie (bundled Natural Languages) can check content -->
|
||||
<grazie.textExtractor language="Lyng"
|
||||
implementationClass="net.sergeych.lyng.idea.grazie.LyngTextExtractor"/>
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
<!--
|
||||
~ Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
~ Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
~
|
||||
~ Licensed under the Apache License, Version 2.0 (the "License");
|
||||
~ you may not use this file except in compliance with the License.
|
||||
@@ -21,8 +21,6 @@
|
||||
-->
|
||||
<idea-plugin>
|
||||
<extensions defaultExtensionNs="com.intellij">
|
||||
<grazie.grammar.strategy language="Lyng"
|
||||
implementationClass="net.sergeych.lyng.idea.grazie.LyngGrazieStrategy"/>
|
||||
<!-- Provide text extraction for Lyng PSI so Grazie can actually check content -->
|
||||
<grazie.textExtractor language="Lyng"
|
||||
implementationClass="net.sergeych.lyng.idea.grazie.LyngTextExtractor"/>
|
||||
|
||||
@@ -16,8 +16,8 @@
|
||||
-->
|
||||
|
||||
<idea-plugin>
|
||||
<!-- Open-ended compatibility: 2024.3+ (build 243 and newer) -->
|
||||
<idea-version since-build="243"/>
|
||||
<!-- Open-ended compatibility: 2024.1+ (build 241 and newer) -->
|
||||
<idea-version since-build="241"/>
|
||||
<id>net.sergeych.lyng.idea</id>
|
||||
<name>Lyng</name>
|
||||
<vendor email="real.sergeych@gmail.com">Sergey Chernov</vendor>
|
||||
@@ -57,9 +57,6 @@
|
||||
<!-- External annotator for semantic highlighting -->
|
||||
<externalAnnotator language="Lyng" implementationClass="net.sergeych.lyng.idea.annotators.LyngExternalAnnotator"/>
|
||||
|
||||
<!-- Grazie-backed spell/grammar annotator (runs only when Grazie is installed) -->
|
||||
<externalAnnotator language="Lyng" implementationClass="net.sergeych.lyng.idea.grazie.LyngGrazieAnnotator"/>
|
||||
|
||||
<!-- Quick documentation provider bound to Lyng language -->
|
||||
<lang.documentationProvider language="Lyng" implementationClass="net.sergeych.lyng.idea.docs.LyngDocumentationProvider"/>
|
||||
|
||||
@@ -105,5 +102,15 @@
|
||||
|
||||
</extensions>
|
||||
|
||||
<actions/>
|
||||
<actions>
|
||||
<action id="net.sergeych.lyng.idea.actions.RunLyngScriptAction"
|
||||
class="net.sergeych.lyng.idea.actions.RunLyngScriptAction"
|
||||
text="Run Lyng Script"
|
||||
description="Run the current Lyng script and show output in console">
|
||||
<add-to-group group-id="EditorPopupMenu" anchor="last"/>
|
||||
<add-to-group group-id="ProjectViewPopupMenu" anchor="last"/>
|
||||
<add-to-group group-id="RunMenu" anchor="last"/>
|
||||
<keyboard-shortcut keymap="$default" first-keystroke="control shift F10"/>
|
||||
</action>
|
||||
</actions>
|
||||
</idea-plugin>
|
||||
@@ -1,5 +1,5 @@
|
||||
<!--
|
||||
~ Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
~ Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
~
|
||||
~ Licensed under the Apache License, Version 2.0 (the "License");
|
||||
~ you may not use this file except in compliance with the License.
|
||||
@@ -22,8 +22,7 @@
|
||||
-->
|
||||
<idea-plugin>
|
||||
<extensions defaultExtensionNs="com.intellij">
|
||||
<!-- Spellchecker strategy: identifiers + comments; literals configurable, skipping printf-like specs -->
|
||||
<spellchecker.support language="Lyng"
|
||||
implementationClass="net.sergeych.lyng.idea.spell.LyngSpellcheckingStrategy"/>
|
||||
implementationClass="net.sergeych.lyng.idea.spell.LyngSpellcheckingStrategy"/>
|
||||
</extensions>
|
||||
</idea-plugin>
|
||||
@@ -1,466 +0,0 @@
|
||||
the
|
||||
be
|
||||
to
|
||||
of
|
||||
and
|
||||
a
|
||||
in
|
||||
that
|
||||
have
|
||||
I
|
||||
it
|
||||
for
|
||||
not
|
||||
on
|
||||
with
|
||||
he
|
||||
as
|
||||
you
|
||||
do
|
||||
at
|
||||
this
|
||||
but
|
||||
his
|
||||
by
|
||||
from
|
||||
they
|
||||
we
|
||||
say
|
||||
her
|
||||
she
|
||||
or
|
||||
an
|
||||
will
|
||||
my
|
||||
one
|
||||
all
|
||||
would
|
||||
there
|
||||
their
|
||||
what
|
||||
so
|
||||
up
|
||||
out
|
||||
if
|
||||
about
|
||||
who
|
||||
get
|
||||
which
|
||||
go
|
||||
me
|
||||
when
|
||||
make
|
||||
can
|
||||
like
|
||||
time
|
||||
no
|
||||
just
|
||||
him
|
||||
know
|
||||
take
|
||||
people
|
||||
into
|
||||
year
|
||||
your
|
||||
good
|
||||
some
|
||||
could
|
||||
them
|
||||
see
|
||||
other
|
||||
than
|
||||
then
|
||||
now
|
||||
look
|
||||
only
|
||||
come
|
||||
its
|
||||
over
|
||||
think
|
||||
also
|
||||
back
|
||||
after
|
||||
use
|
||||
two
|
||||
how
|
||||
our
|
||||
work
|
||||
first
|
||||
well
|
||||
way
|
||||
even
|
||||
new
|
||||
want
|
||||
because
|
||||
any
|
||||
these
|
||||
give
|
||||
day
|
||||
most
|
||||
us
|
||||
is
|
||||
are
|
||||
was
|
||||
were
|
||||
been
|
||||
being
|
||||
does
|
||||
did
|
||||
done
|
||||
has
|
||||
had
|
||||
having
|
||||
may
|
||||
might
|
||||
must
|
||||
shall
|
||||
should
|
||||
ought
|
||||
need
|
||||
used
|
||||
here
|
||||
therefore
|
||||
where
|
||||
why
|
||||
while
|
||||
until
|
||||
since
|
||||
before
|
||||
afterward
|
||||
between
|
||||
among
|
||||
without
|
||||
within
|
||||
through
|
||||
across
|
||||
against
|
||||
toward
|
||||
upon
|
||||
above
|
||||
below
|
||||
under
|
||||
around
|
||||
near
|
||||
far
|
||||
early
|
||||
late
|
||||
often
|
||||
always
|
||||
never
|
||||
seldom
|
||||
sometimes
|
||||
usually
|
||||
really
|
||||
very
|
||||
quite
|
||||
rather
|
||||
almost
|
||||
already
|
||||
again
|
||||
still
|
||||
yet
|
||||
soon
|
||||
today
|
||||
tomorrow
|
||||
yesterday
|
||||
number
|
||||
string
|
||||
boolean
|
||||
true
|
||||
false
|
||||
null
|
||||
none
|
||||
file
|
||||
files
|
||||
path
|
||||
paths
|
||||
line
|
||||
lines
|
||||
word
|
||||
words
|
||||
count
|
||||
value
|
||||
values
|
||||
name
|
||||
names
|
||||
title
|
||||
text
|
||||
message
|
||||
error
|
||||
errors
|
||||
warning
|
||||
warnings
|
||||
info
|
||||
information
|
||||
debug
|
||||
trace
|
||||
format
|
||||
printf
|
||||
specifier
|
||||
specifiers
|
||||
pattern
|
||||
patterns
|
||||
match
|
||||
matches
|
||||
regex
|
||||
version
|
||||
versions
|
||||
module
|
||||
modules
|
||||
package
|
||||
packages
|
||||
import
|
||||
imports
|
||||
export
|
||||
exports
|
||||
class
|
||||
classes
|
||||
object
|
||||
objects
|
||||
function
|
||||
functions
|
||||
method
|
||||
methods
|
||||
parameter
|
||||
parameters
|
||||
argument
|
||||
arguments
|
||||
variable
|
||||
variables
|
||||
constant
|
||||
constants
|
||||
type
|
||||
types
|
||||
generic
|
||||
generics
|
||||
map
|
||||
maps
|
||||
list
|
||||
lists
|
||||
array
|
||||
arrays
|
||||
set
|
||||
sets
|
||||
queue
|
||||
stack
|
||||
graph
|
||||
tree
|
||||
node
|
||||
nodes
|
||||
edge
|
||||
edges
|
||||
pair
|
||||
pairs
|
||||
key
|
||||
keys
|
||||
value
|
||||
values
|
||||
index
|
||||
indices
|
||||
length
|
||||
size
|
||||
empty
|
||||
contains
|
||||
equals
|
||||
compare
|
||||
greater
|
||||
less
|
||||
minimum
|
||||
maximum
|
||||
average
|
||||
sum
|
||||
total
|
||||
random
|
||||
round
|
||||
floor
|
||||
ceil
|
||||
sin
|
||||
cos
|
||||
tan
|
||||
sqrt
|
||||
abs
|
||||
min
|
||||
max
|
||||
read
|
||||
write
|
||||
open
|
||||
close
|
||||
append
|
||||
create
|
||||
delete
|
||||
remove
|
||||
update
|
||||
save
|
||||
load
|
||||
start
|
||||
stop
|
||||
run
|
||||
execute
|
||||
return
|
||||
break
|
||||
continue
|
||||
try
|
||||
catch
|
||||
finally
|
||||
throw
|
||||
throws
|
||||
if
|
||||
else
|
||||
when
|
||||
while
|
||||
for
|
||||
loop
|
||||
range
|
||||
case
|
||||
switch
|
||||
default
|
||||
optional
|
||||
required
|
||||
enable
|
||||
disable
|
||||
enabled
|
||||
disabled
|
||||
visible
|
||||
hidden
|
||||
public
|
||||
private
|
||||
protected
|
||||
internal
|
||||
external
|
||||
inline
|
||||
override
|
||||
abstract
|
||||
sealed
|
||||
open
|
||||
final
|
||||
static
|
||||
const
|
||||
lazy
|
||||
late
|
||||
init
|
||||
initialize
|
||||
configuration
|
||||
settings
|
||||
option
|
||||
options
|
||||
preference
|
||||
preferences
|
||||
project
|
||||
projects
|
||||
module
|
||||
modules
|
||||
build
|
||||
builds
|
||||
compile
|
||||
compiles
|
||||
compiler
|
||||
test
|
||||
tests
|
||||
testing
|
||||
assert
|
||||
assertion
|
||||
result
|
||||
results
|
||||
success
|
||||
failure
|
||||
status
|
||||
state
|
||||
context
|
||||
scope
|
||||
scopes
|
||||
token
|
||||
tokens
|
||||
identifier
|
||||
identifiers
|
||||
keyword
|
||||
keywords
|
||||
comment
|
||||
comments
|
||||
string
|
||||
strings
|
||||
literal
|
||||
literals
|
||||
formatting
|
||||
formatter
|
||||
spell
|
||||
spelling
|
||||
dictionary
|
||||
dictionaries
|
||||
language
|
||||
languages
|
||||
natural
|
||||
grazie
|
||||
typo
|
||||
typos
|
||||
suggest
|
||||
suggestion
|
||||
suggestions
|
||||
replace
|
||||
replacement
|
||||
replacements
|
||||
learn
|
||||
learned
|
||||
learns
|
||||
filter
|
||||
filters
|
||||
exclude
|
||||
excludes
|
||||
include
|
||||
includes
|
||||
bundle
|
||||
bundled
|
||||
resource
|
||||
resources
|
||||
gzipped
|
||||
plain
|
||||
text
|
||||
editor
|
||||
editors
|
||||
inspection
|
||||
inspections
|
||||
highlight
|
||||
highlighting
|
||||
underline
|
||||
underlines
|
||||
style
|
||||
styles
|
||||
range
|
||||
ranges
|
||||
offset
|
||||
offsets
|
||||
position
|
||||
positions
|
||||
apply
|
||||
applies
|
||||
provides
|
||||
present
|
||||
absent
|
||||
available
|
||||
unavailable
|
||||
version
|
||||
build
|
||||
platform
|
||||
ide
|
||||
intellij
|
||||
plugin
|
||||
plugins
|
||||
sandbox
|
||||
gradle
|
||||
kotlin
|
||||
java
|
||||
linux
|
||||
macos
|
||||
windows
|
||||
unix
|
||||
system
|
||||
systems
|
||||
support
|
||||
supports
|
||||
compatible
|
||||
compatibility
|
||||
fallback
|
||||
native
|
||||
automatic
|
||||
autoswitch
|
||||
switch
|
||||
switches
|
||||
@@ -1,282 +0,0 @@
|
||||
# Lyng/tech vocabulary – one word per line, lowercase
|
||||
lyng
|
||||
miniast
|
||||
binder
|
||||
printf
|
||||
specifier
|
||||
specifiers
|
||||
regex
|
||||
regexp
|
||||
token
|
||||
tokens
|
||||
lexer
|
||||
parser
|
||||
syntax
|
||||
semantic
|
||||
highlight
|
||||
highlighting
|
||||
underline
|
||||
typo
|
||||
typos
|
||||
dictionary
|
||||
dictionaries
|
||||
grazie
|
||||
natural
|
||||
languages
|
||||
inspection
|
||||
inspections
|
||||
annotation
|
||||
annotator
|
||||
annotations
|
||||
quickfix
|
||||
quickfixes
|
||||
intention
|
||||
intentions
|
||||
replacement
|
||||
replacements
|
||||
identifier
|
||||
identifiers
|
||||
keyword
|
||||
keywords
|
||||
comment
|
||||
comments
|
||||
string
|
||||
strings
|
||||
literal
|
||||
literals
|
||||
formatting
|
||||
formatter
|
||||
splitter
|
||||
camelcase
|
||||
snakecase
|
||||
pascalcase
|
||||
uppercase
|
||||
lowercase
|
||||
titlecase
|
||||
case
|
||||
cases
|
||||
project
|
||||
module
|
||||
modules
|
||||
resource
|
||||
resources
|
||||
bundle
|
||||
bundled
|
||||
gzipped
|
||||
plaintext
|
||||
text
|
||||
range
|
||||
ranges
|
||||
offset
|
||||
offsets
|
||||
position
|
||||
positions
|
||||
apply
|
||||
applies
|
||||
runtime
|
||||
compile
|
||||
build
|
||||
artifact
|
||||
artifacts
|
||||
plugin
|
||||
plugins
|
||||
intellij
|
||||
idea
|
||||
sandbox
|
||||
gradle
|
||||
kotlin
|
||||
java
|
||||
jvm
|
||||
coroutines
|
||||
suspend
|
||||
scope
|
||||
scopes
|
||||
context
|
||||
contexts
|
||||
tokenizer
|
||||
tokenizers
|
||||
spell
|
||||
spelling
|
||||
spellcheck
|
||||
spellchecker
|
||||
fallback
|
||||
native
|
||||
autoswitch
|
||||
switch
|
||||
switching
|
||||
enable
|
||||
disable
|
||||
enabled
|
||||
disabled
|
||||
setting
|
||||
settings
|
||||
preference
|
||||
preferences
|
||||
editor
|
||||
filetype
|
||||
filetypes
|
||||
language
|
||||
languages
|
||||
psi
|
||||
psielement
|
||||
psifile
|
||||
textcontent
|
||||
textdomain
|
||||
stealth
|
||||
stealthy
|
||||
printfspec
|
||||
format
|
||||
formats
|
||||
pattern
|
||||
patterns
|
||||
match
|
||||
matches
|
||||
group
|
||||
groups
|
||||
node
|
||||
nodes
|
||||
tree
|
||||
graph
|
||||
edge
|
||||
edges
|
||||
pair
|
||||
pairs
|
||||
map
|
||||
maps
|
||||
list
|
||||
lists
|
||||
array
|
||||
arrays
|
||||
set
|
||||
sets
|
||||
queue
|
||||
stack
|
||||
index
|
||||
indices
|
||||
length
|
||||
size
|
||||
empty
|
||||
contains
|
||||
equals
|
||||
compare
|
||||
greater
|
||||
less
|
||||
minimum
|
||||
maximum
|
||||
average
|
||||
sum
|
||||
total
|
||||
random
|
||||
round
|
||||
floor
|
||||
ceil
|
||||
sin
|
||||
cos
|
||||
tan
|
||||
sqrt
|
||||
abs
|
||||
min
|
||||
max
|
||||
read
|
||||
write
|
||||
open
|
||||
close
|
||||
append
|
||||
create
|
||||
delete
|
||||
remove
|
||||
update
|
||||
save
|
||||
load
|
||||
start
|
||||
stop
|
||||
run
|
||||
execute
|
||||
return
|
||||
break
|
||||
continue
|
||||
try
|
||||
catch
|
||||
finally
|
||||
throw
|
||||
throws
|
||||
if
|
||||
else
|
||||
when
|
||||
while
|
||||
for
|
||||
loop
|
||||
rangeop
|
||||
caseop
|
||||
switchop
|
||||
default
|
||||
optional
|
||||
required
|
||||
public
|
||||
private
|
||||
protected
|
||||
internal
|
||||
external
|
||||
inline
|
||||
override
|
||||
abstract
|
||||
sealed
|
||||
open
|
||||
final
|
||||
static
|
||||
const
|
||||
lazy
|
||||
late
|
||||
init
|
||||
initialize
|
||||
configuration
|
||||
option
|
||||
options
|
||||
projectwide
|
||||
workspace
|
||||
crossplatform
|
||||
multiplatform
|
||||
commonmain
|
||||
jsmain
|
||||
native
|
||||
platform
|
||||
api
|
||||
implementation
|
||||
dependency
|
||||
dependencies
|
||||
classpath
|
||||
source
|
||||
sources
|
||||
document
|
||||
documents
|
||||
logging
|
||||
logger
|
||||
info
|
||||
debug
|
||||
trace
|
||||
warning
|
||||
error
|
||||
severity
|
||||
severitylevel
|
||||
intentionaction
|
||||
daemon
|
||||
daemoncodeanalyzer
|
||||
restart
|
||||
textattributes
|
||||
textattributeskey
|
||||
typostyle
|
||||
learned
|
||||
learn
|
||||
tech
|
||||
vocabulary
|
||||
domain
|
||||
term
|
||||
terms
|
||||
us
|
||||
uk
|
||||
american
|
||||
british
|
||||
colour
|
||||
color
|
||||
organisation
|
||||
organization
|
||||
+54
@@ -1,3 +1,20 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyng.idea.completion
|
||||
|
||||
import com.intellij.testFramework.fixtures.BasePlatformTestCase
|
||||
@@ -118,4 +135,41 @@ class LyngCompletionMemberTest : BasePlatformTestCase() {
|
||||
// Heuristic: we expect more than a couple of items (not just size/toList)
|
||||
assertTrue("Too few member suggestions after list literal: $items", items.size >= 3)
|
||||
}
|
||||
|
||||
fun test_ProcessModule_Completion() {
|
||||
val code = """
|
||||
import lyng.io.process
|
||||
Process.<caret>
|
||||
""".trimIndent()
|
||||
val imported = listOf("lyng.io.process")
|
||||
ensureDocs(imported)
|
||||
|
||||
val items = complete(code)
|
||||
assertTrue("Should contain 'execute'", items.contains("execute"))
|
||||
assertTrue("Should contain 'shell'", items.contains("shell"))
|
||||
}
|
||||
|
||||
fun test_RunningProcess_Completion() {
|
||||
val code = """
|
||||
import lyng.io.process
|
||||
val p = Process.shell("ls")
|
||||
p.<caret>
|
||||
""".trimIndent()
|
||||
val imported = listOf("lyng.io.process")
|
||||
ensureDocs(imported)
|
||||
|
||||
val items = complete(code)
|
||||
assertTrue("Should contain 'stdout'", items.contains("stdout"))
|
||||
assertTrue("Should contain 'waitFor'", items.contains("waitFor"))
|
||||
assertTrue("Should contain 'signal'", items.contains("signal"))
|
||||
}
|
||||
|
||||
fun test_RegistryDirect() {
|
||||
DocsBootstrap.ensure()
|
||||
val docs = BuiltinDocRegistry.docsForModule("lyng.io.process")
|
||||
assertTrue("Docs for lyng.io.process should not be empty", docs.isNotEmpty())
|
||||
val processClass = docs.filterIsInstance<MiniClassDecl>().firstOrNull { it.name == "Process" }
|
||||
assertNotNull("Should contain Process class", processClass)
|
||||
assertTrue("Process should have members", processClass!!.members.isNotEmpty())
|
||||
}
|
||||
}
|
||||
@@ -32,6 +32,7 @@ group = "net.sergeych"
|
||||
version = "0.0.1-SNAPSHOT"
|
||||
|
||||
kotlin {
|
||||
jvmToolchain(17)
|
||||
jvm()
|
||||
androidTarget {
|
||||
publishLibraryVariants("release")
|
||||
|
||||
@@ -39,43 +39,174 @@ object FsBuiltinDocs {
|
||||
name = "Path",
|
||||
doc = "Filesystem path class. Construct with a string: `Path(\"/tmp\")`."
|
||||
) {
|
||||
// Common instance methods (subset sufficient for Quick Docs)
|
||||
method(
|
||||
name = "name",
|
||||
doc = "Base name of the path (last segment).",
|
||||
returns = type("lyng.String")
|
||||
)
|
||||
method(
|
||||
name = "parent",
|
||||
doc = "Parent directory as a Path or null if none.",
|
||||
returns = type("Path", nullable = true)
|
||||
)
|
||||
method(
|
||||
name = "segments",
|
||||
doc = "List of path segments.",
|
||||
returns = TypeGenericDoc(type("lyng.List"), listOf(type("lyng.String")))
|
||||
)
|
||||
method(
|
||||
name = "exists",
|
||||
doc = "Whether the path exists on the filesystem.",
|
||||
doc = "Check whether this path exists on the filesystem.",
|
||||
returns = type("lyng.Bool")
|
||||
)
|
||||
method(
|
||||
name = "isFile",
|
||||
doc = "Whether the path exists and is a file.",
|
||||
doc = "True if this path is a regular file (based on cached metadata).",
|
||||
returns = type("lyng.Bool")
|
||||
)
|
||||
method(
|
||||
name = "isDir",
|
||||
doc = "Whether the path exists and is a directory.",
|
||||
name = "isDirectory",
|
||||
doc = "True if this path is a directory (based on cached metadata).",
|
||||
returns = type("lyng.Bool")
|
||||
)
|
||||
method(
|
||||
name = "size",
|
||||
doc = "File size in bytes, or null when unavailable.",
|
||||
returns = type("lyng.Int", nullable = true)
|
||||
)
|
||||
method(
|
||||
name = "createdAt",
|
||||
doc = "Creation time as `Instant`, or null when unavailable.",
|
||||
returns = type("lyng.Instant", nullable = true)
|
||||
)
|
||||
method(
|
||||
name = "createdAtMillis",
|
||||
doc = "Creation time in milliseconds since epoch, or null when unavailable.",
|
||||
returns = type("lyng.Int", nullable = true)
|
||||
)
|
||||
method(
|
||||
name = "modifiedAt",
|
||||
doc = "Last modification time as `Instant`, or null when unavailable.",
|
||||
returns = type("lyng.Instant", nullable = true)
|
||||
)
|
||||
method(
|
||||
name = "modifiedAtMillis",
|
||||
doc = "Last modification time in milliseconds since epoch, or null when unavailable.",
|
||||
returns = type("lyng.Int", nullable = true)
|
||||
)
|
||||
method(
|
||||
name = "list",
|
||||
doc = "List directory entries as `Path` objects.",
|
||||
returns = TypeGenericDoc(type("lyng.List"), listOf(type("Path")))
|
||||
)
|
||||
method(
|
||||
name = "readBytes",
|
||||
doc = "Read the entire file into a binary buffer.",
|
||||
returns = type("lyng.Buffer")
|
||||
)
|
||||
method(
|
||||
name = "writeBytes",
|
||||
doc = "Write a binary buffer to the file, replacing content.",
|
||||
params = listOf(ParamDoc("bytes", type("lyng.Buffer")))
|
||||
)
|
||||
method(
|
||||
name = "appendBytes",
|
||||
doc = "Append a binary buffer to the end of the file.",
|
||||
params = listOf(ParamDoc("bytes", type("lyng.Buffer")))
|
||||
)
|
||||
method(
|
||||
name = "readUtf8",
|
||||
doc = "Read the entire file as UTF-8 string.",
|
||||
doc = "Read the entire file as a UTF-8 string.",
|
||||
returns = type("lyng.String")
|
||||
)
|
||||
method(
|
||||
name = "writeUtf8",
|
||||
doc = "Write UTF-8 string to the file (overwrite).",
|
||||
doc = "Write a UTF-8 string to the file, replacing content.",
|
||||
params = listOf(ParamDoc("text", type("lyng.String")))
|
||||
)
|
||||
method(
|
||||
name = "bytes",
|
||||
doc = "Iterate file content as `Buffer` chunks.",
|
||||
name = "appendUtf8",
|
||||
doc = "Append UTF-8 text to the end of the file.",
|
||||
params = listOf(ParamDoc("text", type("lyng.String")))
|
||||
)
|
||||
method(
|
||||
name = "metadata",
|
||||
doc = "Fetch cached metadata as a map of fields: `isFile`, `isDirectory`, `size`, `createdAtMillis`, `modifiedAtMillis`, `isSymlink`.",
|
||||
returns = TypeGenericDoc(type("lyng.Map"), listOf(type("lyng.String"), type("lyng.Any")))
|
||||
)
|
||||
method(
|
||||
name = "mkdirs",
|
||||
doc = "Create directories (like `mkdir -p`). If `mustCreate` is true and the path already exists, the call fails.",
|
||||
params = listOf(ParamDoc("mustCreate", type("lyng.Bool")))
|
||||
)
|
||||
method(
|
||||
name = "move",
|
||||
doc = "Move this path to a new location. `to` may be a `Path` or `String`.",
|
||||
params = listOf(ParamDoc("to"), ParamDoc("overwrite", type("lyng.Bool")))
|
||||
)
|
||||
method(
|
||||
name = "delete",
|
||||
doc = "Delete this path. `recursively=true` removes directories with their contents.",
|
||||
params = listOf(ParamDoc("mustExist", type("lyng.Bool")), ParamDoc("recursively", type("lyng.Bool")))
|
||||
)
|
||||
method(
|
||||
name = "copy",
|
||||
doc = "Copy this path to a new location. `to` may be a `Path` or `String`.",
|
||||
params = listOf(ParamDoc("to"), ParamDoc("overwrite", type("lyng.Bool")))
|
||||
)
|
||||
method(
|
||||
name = "glob",
|
||||
doc = "List entries matching a glob pattern (no recursion).",
|
||||
params = listOf(ParamDoc("pattern", type("lyng.String"))),
|
||||
returns = TypeGenericDoc(type("lyng.List"), listOf(type("Path")))
|
||||
)
|
||||
method(
|
||||
name = "readChunks",
|
||||
doc = "Read file in fixed-size chunks as an iterator of `Buffer`.",
|
||||
params = listOf(ParamDoc("size", type("lyng.Int"))),
|
||||
returns = TypeGenericDoc(type("lyng.Iterator"), listOf(type("lyng.Buffer")))
|
||||
)
|
||||
method(
|
||||
name = "lines",
|
||||
doc = "Iterate file as lines of text.",
|
||||
name = "readUtf8Chunks",
|
||||
doc = "Read UTF-8 text in fixed-size chunks as an iterator of `String`.",
|
||||
params = listOf(ParamDoc("size", type("lyng.Int"))),
|
||||
returns = TypeGenericDoc(type("lyng.Iterator"), listOf(type("lyng.String")))
|
||||
)
|
||||
method(
|
||||
name = "lines",
|
||||
doc = "Iterate lines of the file as `String` values.",
|
||||
returns = TypeGenericDoc(type("lyng.Iterator"), listOf(type("lyng.String")))
|
||||
)
|
||||
}
|
||||
|
||||
classDoc(
|
||||
name = "BytesIterator",
|
||||
doc = "Iterator over binary chunks."
|
||||
) {
|
||||
method("iterator", "Return this iterator instance.", returns = type("BytesIterator"))
|
||||
method("hasNext", "Whether there is another chunk available.", returns = type("lyng.Bool"))
|
||||
method("next", "Return the next chunk as a `Buffer`.", returns = type("lyng.Buffer"))
|
||||
method("cancelIteration", "Stop the iteration early.")
|
||||
}
|
||||
|
||||
classDoc(
|
||||
name = "StringChunksIterator",
|
||||
doc = "Iterator over UTF-8 text chunks."
|
||||
) {
|
||||
method("iterator", "Return this iterator instance.", returns = type("StringChunksIterator"))
|
||||
method("hasNext", "Whether there is another chunk available.", returns = type("lyng.Bool"))
|
||||
method("next", "Return the next UTF-8 chunk as a `String`.", returns = type("lyng.String"))
|
||||
method("cancelIteration", "Stop the iteration early.")
|
||||
}
|
||||
|
||||
classDoc(
|
||||
name = "LinesIterator",
|
||||
doc = "Iterator that yields lines of text."
|
||||
) {
|
||||
method("iterator", "Return this iterator instance.", returns = type("LinesIterator"))
|
||||
method("hasNext", "Whether another line is available.", returns = type("lyng.Bool"))
|
||||
method("next", "Return the next line as `String`.", returns = type("lyng.String"))
|
||||
method("cancelIteration", "Stop the iteration early.")
|
||||
}
|
||||
|
||||
// Top-level exported constants
|
||||
|
||||
@@ -0,0 +1,117 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyngio.docs
|
||||
|
||||
import net.sergeych.lyng.miniast.BuiltinDocRegistry
|
||||
import net.sergeych.lyng.miniast.ParamDoc
|
||||
import net.sergeych.lyng.miniast.type
|
||||
|
||||
object ProcessBuiltinDocs {
|
||||
private var registered = false
|
||||
|
||||
fun ensure() {
|
||||
if (registered) return
|
||||
BuiltinDocRegistry.module("lyng.io.process") {
|
||||
classDoc(
|
||||
name = "Process",
|
||||
doc = "Process execution and control."
|
||||
) {
|
||||
method(
|
||||
name = "execute",
|
||||
doc = "Execute a process with arguments.",
|
||||
params = listOf(ParamDoc("executable", type("lyng.String")), ParamDoc("args", type("lyng.List"))),
|
||||
returns = type("RunningProcess"),
|
||||
isStatic = true
|
||||
)
|
||||
method(
|
||||
name = "shell",
|
||||
doc = "Execute a command via system shell.",
|
||||
params = listOf(ParamDoc("command", type("lyng.String"))),
|
||||
returns = type("RunningProcess"),
|
||||
isStatic = true
|
||||
)
|
||||
}
|
||||
|
||||
classDoc(
|
||||
name = "Platform",
|
||||
doc = "Platform information."
|
||||
) {
|
||||
method(
|
||||
name = "details",
|
||||
doc = "Get platform core details.",
|
||||
returns = type("lyng.Map"),
|
||||
isStatic = true
|
||||
)
|
||||
method(
|
||||
name = "isSupported",
|
||||
doc = "Check if processes are supported on this platform.",
|
||||
returns = type("lyng.Bool"),
|
||||
isStatic = true
|
||||
)
|
||||
}
|
||||
|
||||
classDoc(
|
||||
name = "RunningProcess",
|
||||
doc = "Handle to a running process."
|
||||
) {
|
||||
method(
|
||||
name = "stdout",
|
||||
doc = "Get standard output stream as a Flow of lines.",
|
||||
returns = type("lyng.Flow")
|
||||
)
|
||||
method(
|
||||
name = "stderr",
|
||||
doc = "Get standard error stream as a Flow of lines.",
|
||||
returns = type("lyng.Flow")
|
||||
)
|
||||
method(
|
||||
name = "signal",
|
||||
doc = "Send a signal to the process (e.g. 'SIGINT', 'SIGTERM', 'SIGKILL').",
|
||||
params = listOf(ParamDoc("signal", type("lyng.String")))
|
||||
)
|
||||
method(
|
||||
name = "waitFor",
|
||||
doc = "Wait for the process to exit and return its exit code.",
|
||||
returns = type("lyng.Int")
|
||||
)
|
||||
method(
|
||||
name = "destroy",
|
||||
doc = "Forcefully terminate the process."
|
||||
)
|
||||
}
|
||||
|
||||
// Top-level exported constants
|
||||
valDoc(
|
||||
name = "Process",
|
||||
doc = "Process execution and control.",
|
||||
type = type("Process")
|
||||
)
|
||||
valDoc(
|
||||
name = "Platform",
|
||||
doc = "Platform information.",
|
||||
type = type("Platform")
|
||||
)
|
||||
valDoc(
|
||||
name = "RunningProcess",
|
||||
doc = "Handle to a running process.",
|
||||
type = type("RunningProcess")
|
||||
)
|
||||
}
|
||||
registered = true
|
||||
}
|
||||
}
|
||||
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.gradle.ExperimentalWasmDsl
|
||||
import org.jetbrains.kotlin.gradle.dsl.JvmTarget
|
||||
|
||||
group = "net.sergeych"
|
||||
version = "1.2.0-SNAPSHOT"
|
||||
version = "1.2.0"
|
||||
|
||||
// Removed legacy buildscript classpath declarations; plugins are applied via the plugins DSL below
|
||||
|
||||
@@ -46,6 +46,7 @@ buildkonfig {
|
||||
}
|
||||
|
||||
kotlin {
|
||||
jvmToolchain(17)
|
||||
jvm()
|
||||
androidTarget {
|
||||
publishLibraryVariants("release")
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
@@ -23,7 +23,7 @@ actual object PerfDefaults {
|
||||
|
||||
actual val ARG_BUILDER: Boolean = true
|
||||
actual val SKIP_ARGS_ON_NULL_RECEIVER: Boolean = true
|
||||
actual val SCOPE_POOL: Boolean = false
|
||||
actual val SCOPE_POOL: Boolean = true
|
||||
|
||||
actual val FIELD_PIC: Boolean = true
|
||||
actual val METHOD_PIC: Boolean = true
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
@@ -18,7 +18,6 @@
|
||||
package net.sergeych.lyng
|
||||
|
||||
import net.sergeych.lyng.obj.Obj
|
||||
import net.sergeych.lyng.obj.ObjVoid
|
||||
|
||||
/**
|
||||
* Android actual: per-thread scope frame pool backed by ThreadLocal.
|
||||
@@ -38,24 +37,31 @@ actual object ScopePool {
|
||||
|
||||
actual fun borrow(parent: Scope, args: Arguments, pos: Pos, thisObj: Obj): Scope {
|
||||
val pool = pool()
|
||||
val s = if (pool.isNotEmpty()) pool.removeLast() else Scope(parent, args, pos, thisObj)
|
||||
return try {
|
||||
if (s.parent !== parent || s.args !== args || s.pos !== pos || s.thisObj !== thisObj) {
|
||||
if (pool.isNotEmpty()) {
|
||||
val s = pool.removeLast()
|
||||
try {
|
||||
// Re-initialize pooled instance
|
||||
s.resetForReuse(parent, args, pos, thisObj)
|
||||
} else {
|
||||
s.frameId = nextFrameId()
|
||||
return s
|
||||
} catch (e: IllegalStateException) {
|
||||
// Defensive fallback: if a cycle in scope parent chain is detected during reuse,
|
||||
// discard pooled instance for this call frame and allocate a fresh scope instead.
|
||||
if (e.message?.contains("cycle") == true && e.message?.contains("scope parent chain") == true) {
|
||||
return Scope(parent, args, pos, thisObj)
|
||||
} else {
|
||||
throw e
|
||||
}
|
||||
}
|
||||
s
|
||||
} catch (e: IllegalStateException) {
|
||||
if (e.message?.contains("cycle") == true && e.message?.contains("scope parent chain") == true) {
|
||||
Scope(parent, args, pos, thisObj)
|
||||
} else throw e
|
||||
}
|
||||
return Scope(parent, args, pos, thisObj)
|
||||
}
|
||||
|
||||
actual fun release(scope: Scope) {
|
||||
val pool = pool()
|
||||
scope.resetForReuse(parent = null, args = Arguments.EMPTY, pos = Pos.builtIn, thisObj = ObjVoid)
|
||||
if (pool.size < MAX_POOL_SIZE) pool.addLast(scope)
|
||||
if (pool.size < MAX_POOL_SIZE) {
|
||||
// Scrub sensitive references to avoid accidental retention before returning to pool
|
||||
scope.scrub()
|
||||
pool.addLast(scope)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -51,6 +51,32 @@ data class ArgsDeclaration(val params: List<Item>, val endTokenType: Token.Type)
|
||||
defaultVisibility: Visibility = Visibility.Public,
|
||||
declaringClass: net.sergeych.lyng.obj.ObjClass? = scope.currentClassCtx
|
||||
) {
|
||||
// Fast path for simple positional-only calls with no ellipsis and no defaults
|
||||
if (arguments.named.isEmpty() && !arguments.tailBlockMode) {
|
||||
var hasComplex = false
|
||||
for (p in params) {
|
||||
if (p.isEllipsis || p.defaultValue != null) {
|
||||
hasComplex = true
|
||||
break
|
||||
}
|
||||
}
|
||||
if (!hasComplex) {
|
||||
if (arguments.list.size != params.size)
|
||||
scope.raiseIllegalArgument("expected ${params.size} arguments, got ${arguments.list.size}")
|
||||
|
||||
for (i in params.indices) {
|
||||
val a = params[i]
|
||||
val value = arguments.list[i]
|
||||
scope.addItem(a.name, (a.accessType ?: defaultAccessType).isMutable,
|
||||
value.byValueCopy(),
|
||||
a.visibility ?: defaultVisibility,
|
||||
recordType = ObjRecord.Type.Argument,
|
||||
declaringClass = declaringClass)
|
||||
}
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
fun assign(a: Item, value: Obj) {
|
||||
scope.addItem(a.name, (a.accessType ?: defaultAccessType).isMutable,
|
||||
value.byValueCopy(),
|
||||
|
||||
@@ -116,10 +116,8 @@ class Compiler(
|
||||
|
||||
private fun consumePendingDoc(): MiniDoc? {
|
||||
if (pendingDocLines.isEmpty()) return null
|
||||
val raw = pendingDocLines.joinToString("\n").trimEnd()
|
||||
val summary = raw.lines().firstOrNull { it.isNotBlank() }?.trim()
|
||||
val start = pendingDocStart ?: cc.currentPos()
|
||||
val doc = MiniDoc(MiniRange(start, start), raw = raw, summary = summary)
|
||||
val doc = MiniDoc.parse(MiniRange(start, start), pendingDocLines)
|
||||
clearPendingDoc()
|
||||
return doc
|
||||
}
|
||||
@@ -169,9 +167,9 @@ class Compiler(
|
||||
miniSink?.onScriptStart(start)
|
||||
do {
|
||||
val t = cc.current()
|
||||
if (t.type == Token.Type.NEWLINE || t.type == Token.Type.SINLGE_LINE_COMMENT || t.type == Token.Type.MULTILINE_COMMENT) {
|
||||
if (t.type == Token.Type.NEWLINE || t.type == Token.Type.SINGLE_LINE_COMMENT || t.type == Token.Type.MULTILINE_COMMENT) {
|
||||
when (t.type) {
|
||||
Token.Type.SINLGE_LINE_COMMENT, Token.Type.MULTILINE_COMMENT -> pushPendingDocToken(t)
|
||||
Token.Type.SINGLE_LINE_COMMENT, Token.Type.MULTILINE_COMMENT -> pushPendingDocToken(t)
|
||||
Token.Type.NEWLINE -> {
|
||||
// A standalone newline not immediately following a comment resets doc buffer
|
||||
if (!prevWasComment) clearPendingDoc() else prevWasComment = false
|
||||
@@ -316,7 +314,7 @@ class Compiler(
|
||||
}
|
||||
|
||||
Token.Type.LABEL -> continue
|
||||
Token.Type.SINLGE_LINE_COMMENT, Token.Type.MULTILINE_COMMENT -> continue
|
||||
Token.Type.SINGLE_LINE_COMMENT, Token.Type.MULTILINE_COMMENT -> continue
|
||||
|
||||
Token.Type.NEWLINE -> continue
|
||||
|
||||
@@ -407,7 +405,7 @@ class Compiler(
|
||||
val t = cc.next()
|
||||
val startPos = t.pos
|
||||
when (t.type) {
|
||||
// Token.Type.NEWLINE, Token.Type.SINLGE_LINE_COMMENT, Token.Type.MULTILINE_COMMENT-> {
|
||||
// Token.Type.NEWLINE, Token.Type.SINGLE_LINE_COMMENT, Token.Type.MULTILINE_COMMENT-> {
|
||||
// continue
|
||||
// }
|
||||
|
||||
@@ -606,7 +604,7 @@ class Compiler(
|
||||
// to skip in parseExpression:
|
||||
val current = cc.current()
|
||||
val right =
|
||||
if (current.type == Token.Type.NEWLINE || current.type == Token.Type.SINLGE_LINE_COMMENT)
|
||||
if (current.type == Token.Type.NEWLINE || current.type == Token.Type.SINGLE_LINE_COMMENT)
|
||||
null
|
||||
else
|
||||
parseExpression()
|
||||
@@ -887,7 +885,7 @@ class Compiler(
|
||||
}
|
||||
|
||||
Token.Type.NEWLINE -> {}
|
||||
Token.Type.MULTILINE_COMMENT, Token.Type.SINLGE_LINE_COMMENT -> {}
|
||||
Token.Type.MULTILINE_COMMENT, Token.Type.SINGLE_LINE_COMMENT -> {}
|
||||
|
||||
Token.Type.ID -> {
|
||||
// visibility
|
||||
@@ -917,12 +915,13 @@ class Compiler(
|
||||
else -> null
|
||||
}
|
||||
|
||||
// type information (semantic + mini syntax)
|
||||
val (typeInfo, miniType) = parseTypeDeclarationWithMini()
|
||||
|
||||
var defaultValue: Statement? = null
|
||||
cc.ifNextIs(Token.Type.ASSIGN) {
|
||||
defaultValue = parseExpression()
|
||||
}
|
||||
// type information (semantic + mini syntax)
|
||||
val (typeInfo, miniType) = parseTypeDeclarationWithMini()
|
||||
val isEllipsis = cc.skipTokenOfType(Token.Type.ELLIPSIS, isOptional = true)
|
||||
result += ArgsDeclaration.Item(
|
||||
t.value,
|
||||
@@ -1049,7 +1048,12 @@ class Compiler(
|
||||
}
|
||||
|
||||
// Nullable suffix after base or generic
|
||||
val isNullable = cc.skipTokenOfType(Token.Type.QUESTION, isOptional = true)
|
||||
val isNullable = if (cc.skipTokenOfType(Token.Type.QUESTION, isOptional = true)) {
|
||||
true
|
||||
} else if (cc.skipTokenOfType(Token.Type.IFNULLASSIGN, isOptional = true)) {
|
||||
cc.pushPendingAssign()
|
||||
true
|
||||
} else false
|
||||
val endPos = cc.currentPos()
|
||||
|
||||
val miniRef = buildBaseRef(if (miniArgs != null) endPos else lastEnd, miniArgs, isNullable)
|
||||
@@ -1734,7 +1738,7 @@ class Compiler(
|
||||
// Rebind error scope to the throw-site position so ScriptError.pos is accurate
|
||||
val throwScope = sc.createChildScope(pos = start)
|
||||
if (errorObject is ObjString) {
|
||||
errorObject = ObjException(throwScope, errorObject.value)
|
||||
errorObject = ObjException(throwScope, errorObject.value).apply { getStackTrace() }
|
||||
}
|
||||
if (!errorObject.isInstanceOf(ObjException.Root)) {
|
||||
throwScope.raiseError("this is not an exception object: $errorObject")
|
||||
@@ -1746,7 +1750,7 @@ class Compiler(
|
||||
errorObject.message,
|
||||
errorObject.extraData,
|
||||
errorObject.useStackTrace
|
||||
)
|
||||
).apply { getStackTrace() }
|
||||
throwScope.raiseError(errorObject)
|
||||
} else {
|
||||
val msg = errorObject.invokeInstanceMethod(sc, "message").toString(sc).value
|
||||
@@ -1877,6 +1881,7 @@ class Compiler(
|
||||
pendingDeclStart = null
|
||||
// so far only simplest enums:
|
||||
val names = mutableListOf<String>()
|
||||
val positions = mutableListOf<Pos>()
|
||||
// skip '{'
|
||||
cc.skipTokenOfType(Token.Type.LBRACE)
|
||||
|
||||
@@ -1885,6 +1890,7 @@ class Compiler(
|
||||
when (t.type) {
|
||||
Token.Type.ID -> {
|
||||
names += t.value
|
||||
positions += t.pos
|
||||
val t1 = cc.nextNonWhitespace()
|
||||
when (t1.type) {
|
||||
Token.Type.COMMA ->
|
||||
@@ -1908,7 +1914,8 @@ class Compiler(
|
||||
entries = names,
|
||||
doc = doc,
|
||||
nameStart = nameToken.pos,
|
||||
isExtern = isExtern
|
||||
isExtern = isExtern,
|
||||
entryPositions = positions
|
||||
)
|
||||
)
|
||||
|
||||
@@ -2734,7 +2741,8 @@ class Compiler(
|
||||
doc = declDocLocal,
|
||||
nameStart = nameStartPos,
|
||||
receiver = receiverMini,
|
||||
isExtern = actualExtern
|
||||
isExtern = actualExtern,
|
||||
isStatic = isStatic
|
||||
)
|
||||
miniSink?.onFunDecl(node)
|
||||
pendingDeclDoc = null
|
||||
@@ -2941,10 +2949,11 @@ class Compiler(
|
||||
doc = declDocLocal,
|
||||
nameStart = nameStartPos,
|
||||
receiver = receiverMini,
|
||||
isExtern = actualExtern
|
||||
isExtern = actualExtern,
|
||||
isStatic = isStatic
|
||||
)
|
||||
miniSink?.onFunDecl(node)
|
||||
miniSink?.onExitFunction(cc.currentPos())
|
||||
miniSink?.onFunDecl(node)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -3002,7 +3011,8 @@ class Compiler(
|
||||
initRange = null,
|
||||
doc = pendingDeclDoc,
|
||||
nameStart = namePos,
|
||||
isExtern = actualExtern
|
||||
isExtern = actualExtern,
|
||||
isStatic = false
|
||||
)
|
||||
miniSink?.onValDecl(node)
|
||||
}
|
||||
@@ -3194,7 +3204,8 @@ class Compiler(
|
||||
doc = pendingDeclDoc,
|
||||
nameStart = nameStartPos,
|
||||
receiver = receiverMini,
|
||||
isExtern = actualExtern
|
||||
isExtern = actualExtern,
|
||||
isStatic = isStatic
|
||||
)
|
||||
miniSink?.onValDecl(node)
|
||||
pendingDeclDoc = null
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
@@ -35,8 +35,9 @@ class CompilerContext(val tokens: List<Token>) {
|
||||
|
||||
var currentIndex = 0
|
||||
private var pendingGT = 0
|
||||
private var pendingAssign = false
|
||||
|
||||
fun hasNext() = currentIndex < tokens.size || pendingGT > 0
|
||||
fun hasNext() = currentIndex < tokens.size || pendingGT > 0 || pendingAssign
|
||||
fun hasPrevious() = currentIndex > 0
|
||||
fun next(): Token {
|
||||
if (pendingGT > 0) {
|
||||
@@ -44,6 +45,11 @@ class CompilerContext(val tokens: List<Token>) {
|
||||
val last = tokens[currentIndex - 1]
|
||||
return Token(">", last.pos.copy(column = last.pos.column + 1), Token.Type.GT)
|
||||
}
|
||||
if (pendingAssign) {
|
||||
pendingAssign = false
|
||||
val last = tokens[currentIndex - 1]
|
||||
return Token("=", last.pos.copy(column = last.pos.column + 1), Token.Type.ASSIGN)
|
||||
}
|
||||
return if (currentIndex < tokens.size) tokens[currentIndex++]
|
||||
else Token("", tokens.last().pos, Token.Type.EOF)
|
||||
}
|
||||
@@ -52,16 +58,19 @@ class CompilerContext(val tokens: List<Token>) {
|
||||
pendingGT++
|
||||
}
|
||||
|
||||
fun previous() = if (pendingGT > 0) {
|
||||
pendingGT-- // This is wrong, previous should go back.
|
||||
// But we don't really use previous() in generics parser after splitting.
|
||||
throw IllegalStateException("previous() not supported after pushPendingGT")
|
||||
fun pushPendingAssign() {
|
||||
pendingAssign = true
|
||||
}
|
||||
|
||||
fun previous() = if (pendingGT > 0 || pendingAssign) {
|
||||
throw IllegalStateException("previous() not supported after pushPending tokens")
|
||||
} else if (!hasPrevious()) throw IllegalStateException("No previous token") else tokens[--currentIndex]
|
||||
|
||||
fun savePos() = (currentIndex shl 2) or (pendingGT and 3)
|
||||
fun savePos() = (currentIndex shl 3) or (pendingGT and 3) or (if (pendingAssign) 4 else 0)
|
||||
fun restorePos(pos: Int) {
|
||||
currentIndex = pos shr 2
|
||||
currentIndex = pos shr 3
|
||||
pendingGT = pos and 3
|
||||
pendingAssign = (pos and 4) != 0
|
||||
}
|
||||
|
||||
fun ensureLabelIsValid(pos: Pos, label: String) {
|
||||
@@ -238,7 +247,7 @@ class CompilerContext(val tokens: List<Token>) {
|
||||
}
|
||||
}
|
||||
|
||||
Token.Type.MULTILINE_COMMENT, Token.Type.SINLGE_LINE_COMMENT, Token.Type.NEWLINE -> {}
|
||||
Token.Type.MULTILINE_COMMENT, Token.Type.SINGLE_LINE_COMMENT, Token.Type.NEWLINE -> {}
|
||||
else -> {
|
||||
restorePos(pos); return false
|
||||
}
|
||||
@@ -265,6 +274,6 @@ class CompilerContext(val tokens: List<Token>) {
|
||||
}
|
||||
|
||||
companion object {
|
||||
val wstokens = setOf(Token.Type.NEWLINE, Token.Type.MULTILINE_COMMENT, Token.Type.SINLGE_LINE_COMMENT)
|
||||
val wstokens = setOf(Token.Type.NEWLINE, Token.Type.MULTILINE_COMMENT, Token.Type.SINGLE_LINE_COMMENT)
|
||||
}
|
||||
}
|
||||
@@ -131,7 +131,7 @@ private class Parser(fromPos: Pos) {
|
||||
pos.advance()
|
||||
val body = loadToEndOfLine()
|
||||
// Include the leading '//' and do not trim; keep exact lexeme (excluding preceding codepoint)
|
||||
Token("//" + body, from, Token.Type.SINLGE_LINE_COMMENT)
|
||||
Token("//" + body, from, Token.Type.SINGLE_LINE_COMMENT)
|
||||
}
|
||||
|
||||
'*' -> {
|
||||
|
||||
@@ -70,9 +70,8 @@ open class Scope(
|
||||
|
||||
internal fun findExtension(receiverClass: ObjClass, name: String): ObjRecord? {
|
||||
var s: Scope? = this
|
||||
val visited = HashSet<Long>(4)
|
||||
while (s != null) {
|
||||
if (!visited.add(s.frameId)) break
|
||||
var hops = 0
|
||||
while (s != null && hops++ < 1024) {
|
||||
// Proximity rule: check all extensions in the current scope before going to parent.
|
||||
// Priority within scope: more specific class in MRO wins.
|
||||
for (cls in receiverClass.mro) {
|
||||
@@ -108,7 +107,7 @@ open class Scope(
|
||||
*/
|
||||
internal fun tryGetLocalRecord(s: Scope, name: String, caller: net.sergeych.lyng.obj.ObjClass?): ObjRecord? {
|
||||
caller?.let { ctx ->
|
||||
s.objects["${ctx.className}::$name"]?.let { rec ->
|
||||
s.objects[ctx.mangledName(name)]?.let { rec ->
|
||||
if (rec.visibility == Visibility.Private) return rec
|
||||
}
|
||||
}
|
||||
@@ -116,7 +115,7 @@ open class Scope(
|
||||
if (rec.declaringClass == null || canAccessMember(rec.visibility, rec.declaringClass, caller)) return rec
|
||||
}
|
||||
caller?.let { ctx ->
|
||||
s.localBindings["${ctx.className}::$name"]?.let { rec ->
|
||||
s.localBindings[ctx.mangledName(name)]?.let { rec ->
|
||||
if (rec.visibility == Visibility.Private) return rec
|
||||
}
|
||||
}
|
||||
@@ -132,11 +131,10 @@ open class Scope(
|
||||
|
||||
internal fun chainLookupIgnoreClosure(name: String, followClosure: Boolean = false, caller: net.sergeych.lyng.obj.ObjClass? = null): ObjRecord? {
|
||||
var s: Scope? = this
|
||||
// use frameId to detect unexpected structural cycles in the parent chain
|
||||
val visited = HashSet<Long>(4)
|
||||
// use hop counter to detect unexpected structural cycles in the parent chain
|
||||
var hops = 0
|
||||
val effectiveCaller = caller ?: currentClassCtx
|
||||
while (s != null) {
|
||||
if (!visited.add(s.frameId)) return null
|
||||
while (s != null && hops++ < 1024) {
|
||||
tryGetLocalRecord(s, name, effectiveCaller)?.let { return it }
|
||||
s = if (followClosure && s is ClosureScope) s.closureScope else s.parent
|
||||
}
|
||||
@@ -155,9 +153,8 @@ open class Scope(
|
||||
tryGetLocalRecord(this, name, currentClassCtx)?.let { return it }
|
||||
// 2) walk parents for plain locals/bindings only
|
||||
var s = parent
|
||||
val visited = HashSet<Long>(4)
|
||||
while (s != null) {
|
||||
if (!visited.add(s.frameId)) return null
|
||||
var hops = 0
|
||||
while (s != null && hops++ < 1024) {
|
||||
tryGetLocalRecord(s, name, currentClassCtx)?.let { return it }
|
||||
s = s.parent
|
||||
}
|
||||
@@ -182,9 +179,8 @@ open class Scope(
|
||||
*/
|
||||
internal fun chainLookupWithMembers(name: String, caller: net.sergeych.lyng.obj.ObjClass? = currentClassCtx, followClosure: Boolean = false): ObjRecord? {
|
||||
var s: Scope? = this
|
||||
val visited = HashSet<Long>(4)
|
||||
while (s != null) {
|
||||
if (!visited.add(s.frameId)) return null
|
||||
var hops = 0
|
||||
while (s != null && hops++ < 1024) {
|
||||
tryGetLocalRecord(s, name, caller)?.let { return it }
|
||||
for (cls in s.thisObj.objClass.mro) {
|
||||
s.extensions[cls]?.get(name)?.let { return it }
|
||||
@@ -396,6 +392,20 @@ open class Scope(
|
||||
nameToSlot[name]?.let { slots[it] = record }
|
||||
}
|
||||
|
||||
/**
|
||||
* Clear all references and maps to prevent memory leaks when pooled.
|
||||
*/
|
||||
fun scrub() {
|
||||
this.parent = null
|
||||
this.skipScopeCreation = false
|
||||
this.currentClassCtx = null
|
||||
objects.clear()
|
||||
slots.clear()
|
||||
nameToSlot.clear()
|
||||
localBindings.clear()
|
||||
extensions.clear()
|
||||
}
|
||||
|
||||
/**
|
||||
* Reset this scope instance so it can be safely reused as a fresh child frame.
|
||||
* Clears locals and slots, assigns new frameId, and sets parent/args/pos/thisObj.
|
||||
@@ -414,7 +424,6 @@ open class Scope(
|
||||
nameToSlot.clear()
|
||||
localBindings.clear()
|
||||
extensions.clear()
|
||||
this.currentClassCtx = parent?.currentClassCtx
|
||||
// Now safe to validate and re-parent
|
||||
ensureNoCycle(parent)
|
||||
this.parent = parent
|
||||
@@ -534,11 +543,15 @@ open class Scope(
|
||||
}
|
||||
}
|
||||
// Map to a slot for fast local access (ensure consistency)
|
||||
val idx = getSlotIndexOf(name)
|
||||
if (idx == null) {
|
||||
if (nameToSlot.isEmpty()) {
|
||||
allocateSlotFor(name, rec)
|
||||
} else {
|
||||
slots[idx] = rec
|
||||
val idx = nameToSlot[name]
|
||||
if (idx == null) {
|
||||
allocateSlotFor(name, rec)
|
||||
} else {
|
||||
slots[idx] = rec
|
||||
}
|
||||
}
|
||||
return rec
|
||||
}
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
@@ -21,7 +21,7 @@ import net.sergeych.lyng.obj.Obj
|
||||
|
||||
/**
|
||||
* Expect/actual portable scope frame pool. Used only when [PerfFlags.SCOPE_POOL] is true.
|
||||
* JVM actual provides a ThreadLocal-backed pool; other targets may use a simple global deque.
|
||||
* Provides per-thread pooling on JVM, Android, and Native; global pooling on JS and Wasm.
|
||||
*/
|
||||
expect object ScopePool {
|
||||
fun borrow(parent: Scope, args: Arguments, pos: Pos, thisObj: Obj): Scope
|
||||
|
||||
@@ -22,7 +22,7 @@ data class Token(val value: String, val pos: Pos, val type: Type) {
|
||||
throw ScriptError(pos, text)
|
||||
}
|
||||
|
||||
val isComment: Boolean by lazy { type == Type.SINLGE_LINE_COMMENT || type == Type.MULTILINE_COMMENT }
|
||||
val isComment: Boolean by lazy { type == Type.SINGLE_LINE_COMMENT || type == Type.MULTILINE_COMMENT }
|
||||
|
||||
fun isId(text: String) =
|
||||
type == Type.ID && value == text
|
||||
@@ -41,7 +41,7 @@ data class Token(val value: String, val pos: Pos, val type: Type) {
|
||||
SHUTTLE,
|
||||
AND, BITAND, OR, BITOR, BITXOR, NOT, BITNOT, DOT, ARROW, EQARROW, QUESTION, COLONCOLON,
|
||||
SHL, SHR,
|
||||
SINLGE_LINE_COMMENT, MULTILINE_COMMENT,
|
||||
SINGLE_LINE_COMMENT, MULTILINE_COMMENT,
|
||||
LABEL, ATLABEL, // label@ at@label
|
||||
// type-checking/casting
|
||||
AS, ASNULL, OBJECT,
|
||||
|
||||
@@ -35,7 +35,8 @@ data class Symbol(
|
||||
val kind: SymbolKind,
|
||||
val declStart: Int,
|
||||
val declEnd: Int,
|
||||
val containerId: Int?
|
||||
val containerId: Int?,
|
||||
val type: String? = null
|
||||
)
|
||||
|
||||
data class Reference(val symbolId: Int, val start: Int, val end: Int)
|
||||
@@ -97,59 +98,83 @@ object Binder {
|
||||
// First pass (classes only): register classes so we can attach methods/fields
|
||||
for (d in mini.declarations) if (d is MiniClassDecl) {
|
||||
val (s, e) = nameOffsets(d.nameStart, d.name)
|
||||
val sym = Symbol(nextId++, d.name, SymbolKind.Class, s, e, containerId = null)
|
||||
val sym = Symbol(nextId++, d.name, SymbolKind.Class, s, e, containerId = null, type = d.name)
|
||||
symbols += sym
|
||||
topLevelByName.getOrPut(d.name) { mutableListOf() }.add(sym.id)
|
||||
// Prefer explicit body range; otherwise use the whole class declaration range
|
||||
val bodyStart = d.bodyRange?.start?.let { source.offsetOf(it) } ?: source.offsetOf(d.range.start)
|
||||
val bodyEnd = d.bodyRange?.end?.let { source.offsetOf(it) } ?: source.offsetOf(d.range.end)
|
||||
classes += ClassScope(sym.id, bodyStart, bodyEnd, mutableListOf())
|
||||
val classScope = ClassScope(sym.id, bodyStart, bodyEnd, mutableListOf())
|
||||
classes += classScope
|
||||
// Constructor fields (val/var in primary ctor)
|
||||
for (cf in d.ctorFields) {
|
||||
val fs = source.offsetOf(cf.nameStart)
|
||||
val fe = fs + cf.name.length
|
||||
val kind = if (cf.mutable) SymbolKind.Variable else SymbolKind.Value
|
||||
val fieldSym = Symbol(nextId++, cf.name, kind, fs, fe, containerId = sym.id)
|
||||
val fieldSym = Symbol(nextId++, cf.name, kind, fs, fe, containerId = sym.id, type = DocLookupUtils.typeOf(cf.type))
|
||||
symbols += fieldSym
|
||||
classes.last().fields += fieldSym.id
|
||||
classScope.fields += fieldSym.id
|
||||
}
|
||||
// Class fields (val/var in class body, if any are reported here)
|
||||
for (cf in d.classFields) {
|
||||
val fs = source.offsetOf(cf.nameStart)
|
||||
val fe = fs + cf.name.length
|
||||
val kind = if (cf.mutable) SymbolKind.Variable else SymbolKind.Value
|
||||
val fieldSym = Symbol(nextId++, cf.name, kind, fs, fe, containerId = sym.id)
|
||||
val fieldSym = Symbol(nextId++, cf.name, kind, fs, fe, containerId = sym.id, type = DocLookupUtils.typeOf(cf.type))
|
||||
symbols += fieldSym
|
||||
classes.last().fields += fieldSym.id
|
||||
classScope.fields += fieldSym.id
|
||||
}
|
||||
// Members (including fields and methods)
|
||||
for (m in d.members) {
|
||||
if (m is MiniMemberValDecl) {
|
||||
val fs = source.offsetOf(m.nameStart)
|
||||
val fe = fs + m.name.length
|
||||
val kind = if (m.mutable) SymbolKind.Variable else SymbolKind.Value
|
||||
val fieldSym = Symbol(nextId++, m.name, kind, fs, fe, containerId = sym.id, type = DocLookupUtils.typeOf(m.type))
|
||||
symbols += fieldSym
|
||||
classScope.fields += fieldSym.id
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fun registerFun(name: String, nameStart: net.sergeych.lyng.Pos, params: List<MiniParam>, returnType: MiniTypeRef?, bodyRange: MiniRange?, isTopLevel: Boolean) {
|
||||
val (s, e) = nameOffsets(nameStart, name)
|
||||
val ownerClass = classContaining(s)
|
||||
val sym = Symbol(nextId++, name, SymbolKind.Function, s, e, containerId = ownerClass?.symId, type = DocLookupUtils.typeOf(returnType))
|
||||
symbols += sym
|
||||
if (isTopLevel) {
|
||||
topLevelByName.getOrPut(name) { mutableListOf() }.add(sym.id)
|
||||
}
|
||||
|
||||
// Determine body range if present; otherwise, derive a conservative end at decl range end
|
||||
val bodyStart = bodyRange?.start?.let { source.offsetOf(it) } ?: e
|
||||
val bodyEnd = bodyRange?.end?.let { source.offsetOf(it) } ?: e
|
||||
val fnScope = FnScope(sym.id, bodyStart, bodyEnd, mutableListOf(), ownerClass?.symId)
|
||||
|
||||
// Params
|
||||
for (p in params) {
|
||||
val ps = source.offsetOf(p.nameStart)
|
||||
val pe = ps + p.name.length
|
||||
val pk = SymbolKind.Parameter
|
||||
val paramSym = Symbol(nextId++, p.name, pk, ps, pe, containerId = sym.id, type = DocLookupUtils.typeOf(p.type))
|
||||
fnScope.locals += paramSym.id
|
||||
symbols += paramSym
|
||||
}
|
||||
functions += fnScope
|
||||
}
|
||||
|
||||
// Second pass: functions and top-level/class vals/vars
|
||||
for (d in mini.declarations) {
|
||||
when (d) {
|
||||
is MiniClassDecl -> { /* already processed in first pass */ }
|
||||
is MiniFunDecl -> {
|
||||
val (s, e) = nameOffsets(d.nameStart, d.name)
|
||||
val ownerClass = classContaining(s)
|
||||
val sym = Symbol(nextId++, d.name, SymbolKind.Function, s, e, containerId = ownerClass?.symId)
|
||||
symbols += sym
|
||||
topLevelByName.getOrPut(d.name) { mutableListOf() }.add(sym.id)
|
||||
|
||||
// Determine body range if present; otherwise, derive a conservative end at decl range end
|
||||
val bodyStart = d.body?.range?.start?.let { source.offsetOf(it) } ?: e
|
||||
val bodyEnd = d.body?.range?.end?.let { source.offsetOf(it) } ?: e
|
||||
val fnScope = FnScope(sym.id, bodyStart, bodyEnd, mutableListOf(), ownerClass?.symId)
|
||||
|
||||
// Params
|
||||
for (p in d.params) {
|
||||
val ps = source.offsetOf(p.nameStart)
|
||||
val pe = ps + p.name.length
|
||||
val pk = SymbolKind.Parameter
|
||||
val paramSym = Symbol(nextId++, p.name, pk, ps, pe, containerId = sym.id)
|
||||
fnScope.locals += paramSym.id
|
||||
symbols += paramSym
|
||||
is MiniClassDecl -> {
|
||||
for (m in d.members) {
|
||||
if (m is MiniMemberFunDecl) {
|
||||
registerFun(m.name, m.nameStart, m.params, m.returnType, m.body?.range, false)
|
||||
}
|
||||
}
|
||||
functions += fnScope
|
||||
}
|
||||
is MiniFunDecl -> {
|
||||
registerFun(d.name, d.nameStart, d.params, d.returnType, d.body?.range, true)
|
||||
}
|
||||
is MiniValDecl -> {
|
||||
val (s, e) = nameOffsets(d.nameStart, d.name)
|
||||
@@ -157,18 +182,18 @@ object Binder {
|
||||
val ownerClass = classContaining(s)
|
||||
if (ownerClass != null) {
|
||||
// class field
|
||||
val fieldSym = Symbol(nextId++, d.name, kind, s, e, containerId = ownerClass.symId)
|
||||
val fieldSym = Symbol(nextId++, d.name, kind, s, e, containerId = ownerClass.symId, type = DocLookupUtils.typeOf(d.type))
|
||||
symbols += fieldSym
|
||||
ownerClass.fields += fieldSym.id
|
||||
} else {
|
||||
val sym = Symbol(nextId++, d.name, kind, s, e, containerId = null)
|
||||
val sym = Symbol(nextId++, d.name, kind, s, e, containerId = null, type = DocLookupUtils.typeOf(d.type))
|
||||
symbols += sym
|
||||
topLevelByName.getOrPut(d.name) { mutableListOf() }.add(sym.id)
|
||||
}
|
||||
}
|
||||
is MiniEnumDecl -> {
|
||||
val (s, e) = nameOffsets(d.nameStart, d.name)
|
||||
val sym = Symbol(nextId++, d.name, SymbolKind.Enum, s, e, containerId = null)
|
||||
val sym = Symbol(nextId++, d.name, SymbolKind.Enum, s, e, containerId = null, type = d.name)
|
||||
symbols += sym
|
||||
topLevelByName.getOrPut(d.name) { mutableListOf() }.add(sym.id)
|
||||
}
|
||||
@@ -187,7 +212,7 @@ object Binder {
|
||||
"iterator", "hasNext", "next"
|
||||
)
|
||||
for (name in stdFns) {
|
||||
val sym = Symbol(nextId++, name, SymbolKind.Function, 0, name.length, containerId = null)
|
||||
val sym = Symbol(nextId++, name, SymbolKind.Function, 0, name.length, containerId = null, type = null)
|
||||
symbols += sym
|
||||
topLevelByName.getOrPut(name) { mutableListOf() }.add(sym.id)
|
||||
}
|
||||
@@ -204,7 +229,7 @@ object Binder {
|
||||
if (containerFn != null) {
|
||||
val fnSymId = containerFn.id
|
||||
val kind = if (d.mutable) SymbolKind.Variable else SymbolKind.Value
|
||||
val localSym = Symbol(nextId++, d.name, kind, s, e, containerId = fnSymId)
|
||||
val localSym = Symbol(nextId++, d.name, kind, s, e, containerId = fnSymId, type = DocLookupUtils.typeOf(d.type))
|
||||
symbols += localSym
|
||||
containerFn.locals += localSym.id
|
||||
}
|
||||
@@ -245,11 +270,11 @@ object Binder {
|
||||
.maxByOrNull { it.rangeEnd - it.rangeStart }
|
||||
val kind = if (kw.equals("var", true)) SymbolKind.Variable else SymbolKind.Value
|
||||
if (inFn != null) {
|
||||
val localSym = Symbol(nextId++, text.substring(nameStart, nameEnd), kind, nameStart, nameEnd, containerId = inFn.id)
|
||||
val localSym = Symbol(nextId++, text.substring(nameStart, nameEnd), kind, nameStart, nameEnd, containerId = inFn.id, type = null)
|
||||
symbols += localSym
|
||||
inFn.locals += localSym.id
|
||||
} else {
|
||||
val localSym = Symbol(nextId++, text.substring(nameStart, nameEnd), kind, nameStart, nameEnd, containerId = null)
|
||||
val localSym = Symbol(nextId++, text.substring(nameStart, nameEnd), kind, nameStart, nameEnd, containerId = null, type = null)
|
||||
symbols += localSym
|
||||
topLevelByName.getOrPut(localSym.name) { mutableListOf() }.add(localSym.id)
|
||||
}
|
||||
|
||||
@@ -100,11 +100,16 @@ object LyngFormatter {
|
||||
fun isControlHeaderNoBrace(s: String): Boolean {
|
||||
val t = s.trim()
|
||||
if (t.isEmpty()) return false
|
||||
// match: if (...) | else if (...) | else
|
||||
val isIf = Regex("^if\\s*\\(.*\\)\\s*$").matches(t)
|
||||
val isElseIf = Regex("^else\\s+if\\s*\\(.*\\)\\s*$").matches(t)
|
||||
val isElse = t == "else"
|
||||
if (isIf || isElseIf || isElse) return true
|
||||
// match: if (...) | else if (...) | else | catch (...) | finally
|
||||
if (Regex("^if\\s*\\(.*\\)$").matches(t)) return true
|
||||
if (Regex("^else\\s+if\\s*\\(.*\\)$").matches(t)) return true
|
||||
if (t == "else") return true
|
||||
if (Regex("^catch\\s*\\(.*\\)$").matches(t)) return true
|
||||
if (t == "finally") return true
|
||||
|
||||
// Short definition form: fun x() = or val x =
|
||||
if (Regex("^(override\\s+)?(fun|fn)\\b.*=\\s*$").matches(t)) return true
|
||||
if (Regex("^(private\\s+|protected\\s+|public\\s+|override\\s+)?(val|var)\\b.*=\\s*$").matches(t)) return true
|
||||
|
||||
// property accessors ending with ) or =
|
||||
if (isAccessorRelated(t)) {
|
||||
@@ -113,11 +118,23 @@ object LyngFormatter {
|
||||
return false
|
||||
}
|
||||
|
||||
fun isDoubleIndentHeader(s: String): Boolean {
|
||||
val t = s.trim()
|
||||
if (!t.endsWith("=")) return false
|
||||
// Is it a function or property definition?
|
||||
if (Regex("\\b(fun|fn|val|var)\\b").containsMatchIn(t)) return true
|
||||
// Is it an accessor?
|
||||
if (isPropertyAccessor(t)) return true
|
||||
return false
|
||||
}
|
||||
|
||||
for ((i, rawLine) in lines.withIndex()) {
|
||||
val (parts, nextInBlockComment) = splitIntoParts(rawLine, inBlockComment)
|
||||
val code = parts.filter { it.type == PartType.Code }.joinToString("") { it.text }
|
||||
val codeAndStrings = parts.filter { it.type != PartType.BlockComment && it.type != PartType.LineComment }.joinToString("") { it.text }
|
||||
val trimmedStart = code.dropWhile { it == ' ' || it == '\t' }
|
||||
val trimmedLine = rawLine.trim()
|
||||
val trimmedCodeAndStrings = codeAndStrings.trim()
|
||||
|
||||
// Compute effective indent level for this line
|
||||
val currentExtraIndent = extraIndents.sum()
|
||||
@@ -138,9 +155,15 @@ object LyngFormatter {
|
||||
|
||||
// Single-line control header (if/else/else if) without braces: indent the next
|
||||
// non-empty, non-'}', non-'else' line by one extra level
|
||||
val isContinuation = trimmedStart.startsWith("else") || trimmedStart.startsWith("catch") || trimmedStart.startsWith("finally")
|
||||
val applyAwaiting = awaitingExtraIndent > 0 && trimmedStart.isNotEmpty() &&
|
||||
!trimmedStart.startsWith("else") && !trimmedStart.startsWith("}")
|
||||
if (applyAwaiting) effectiveLevel += awaitingExtraIndent
|
||||
!trimmedStart.startsWith("}")
|
||||
var actualAwaiting = 0
|
||||
if (applyAwaiting) {
|
||||
actualAwaiting = awaitingExtraIndent
|
||||
if (isContinuation) actualAwaiting = (actualAwaiting - 1).coerceAtLeast(0)
|
||||
effectiveLevel += actualAwaiting
|
||||
}
|
||||
|
||||
val firstChar = trimmedStart.firstOrNull()
|
||||
// While inside parentheses, continuation applies scaled by nesting level
|
||||
@@ -194,7 +217,7 @@ object LyngFormatter {
|
||||
val newBlockLevel = blockLevel
|
||||
if (newBlockLevel > oldBlockLevel) {
|
||||
val isAccessorRelatedLine = isAccessor || (!inBlockComment && isAccessorRelated(code))
|
||||
val addedThisLine = (if (applyAwaiting) awaitingExtraIndent else 0) + (if (isAccessorRelatedLine) 1 else 0)
|
||||
val addedThisLine = actualAwaiting + (if (isAccessorRelatedLine) 1 else 0)
|
||||
repeat(newBlockLevel - oldBlockLevel) {
|
||||
extraIndents.add(addedThisLine)
|
||||
}
|
||||
@@ -207,23 +230,29 @@ object LyngFormatter {
|
||||
inBlockComment = nextInBlockComment
|
||||
|
||||
// Update awaitingExtraIndent based on current line
|
||||
val nextLineTrimmed = lines.getOrNull(i + 1)?.trim() ?: ""
|
||||
val nextIsContinuation = nextLineTrimmed.startsWith("else") ||
|
||||
nextLineTrimmed.startsWith("catch") ||
|
||||
nextLineTrimmed.startsWith("finally")
|
||||
|
||||
if (applyAwaiting && trimmedStart.isNotEmpty()) {
|
||||
// we have just applied it.
|
||||
val endsWithBrace = code.trimEnd().endsWith("{")
|
||||
if (!endsWithBrace && isControlHeaderNoBrace(code)) {
|
||||
if (!endsWithBrace && isControlHeaderNoBrace(trimmedCodeAndStrings)) {
|
||||
// It's another header, increment
|
||||
val isAccessorRelatedLine = isAccessor || (!inBlockComment && isAccessorRelated(code))
|
||||
awaitingExtraIndent += if (isAccessorRelatedLine) 2 else 1
|
||||
} else {
|
||||
// It's the body, reset
|
||||
val isAccessorOrDouble = isAccessor || (!inBlockComment && isAccessorRelated(code)) || isDoubleIndentHeader(trimmedCodeAndStrings)
|
||||
val increment = if (isAccessorOrDouble) 2 else 1
|
||||
awaitingExtraIndent = actualAwaiting + increment
|
||||
} else if (!nextIsContinuation) {
|
||||
// It's the body, and no continuation follows, so reset
|
||||
awaitingExtraIndent = 0
|
||||
}
|
||||
} else {
|
||||
// start awaiting if current line is a control header without '{'
|
||||
val endsWithBrace = code.trimEnd().endsWith("{")
|
||||
if (!endsWithBrace && isControlHeaderNoBrace(code)) {
|
||||
val isAccessorRelatedLine = isAccessor || (!inBlockComment && isAccessorRelated(code))
|
||||
awaitingExtraIndent = if (isAccessorRelatedLine) 2 else 1
|
||||
if (!endsWithBrace && isControlHeaderNoBrace(trimmedCodeAndStrings)) {
|
||||
val isAccessorOrDouble = isAccessor || (!inBlockComment && isAccessorRelated(code)) || isDoubleIndentHeader(trimmedCodeAndStrings)
|
||||
awaitingExtraIndent = if (isAccessorOrDouble) 2 else 1
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -42,7 +42,7 @@ private val fallbackKeywordIds = setOf(
|
||||
"and", "or", "not",
|
||||
// declarations & modifiers
|
||||
"fun", "fn", "class", "interface", "enum", "val", "var", "import", "package",
|
||||
"abstract", "closed", "override",
|
||||
"abstract", "closed", "override", "public", "lazy", "dynamic",
|
||||
"private", "protected", "static", "open", "extern", "init", "get", "set", "by",
|
||||
// control flow and misc
|
||||
"if", "else", "when", "while", "do", "for", "try", "catch", "finally",
|
||||
@@ -67,7 +67,7 @@ private fun kindOf(type: Type, value: String): HighlightKind? = when (type) {
|
||||
Type.REGEX -> HighlightKind.Regex
|
||||
|
||||
// comments
|
||||
Type.SINLGE_LINE_COMMENT, Type.MULTILINE_COMMENT -> HighlightKind.Comment
|
||||
Type.SINGLE_LINE_COMMENT, Type.MULTILINE_COMMENT -> HighlightKind.Comment
|
||||
|
||||
// punctuation
|
||||
Type.LPAREN, Type.RPAREN, Type.LBRACE, Type.RBRACE, Type.LBRACKET, Type.RBRACKET,
|
||||
|
||||
@@ -148,6 +148,8 @@ class ModuleDocsBuilder internal constructor(private val moduleName: String) {
|
||||
body = null,
|
||||
doc = md,
|
||||
nameStart = Pos.builtIn,
|
||||
isExtern = false,
|
||||
isStatic = false
|
||||
)
|
||||
}
|
||||
|
||||
@@ -167,6 +169,8 @@ class ModuleDocsBuilder internal constructor(private val moduleName: String) {
|
||||
initRange = null,
|
||||
doc = md,
|
||||
nameStart = Pos.builtIn,
|
||||
isExtern = false,
|
||||
isStatic = false
|
||||
)
|
||||
}
|
||||
|
||||
@@ -251,8 +255,7 @@ class ClassDocsBuilder internal constructor(private val className: String) {
|
||||
private fun builtinRange() = MiniRange(Pos.builtIn, Pos.builtIn)
|
||||
|
||||
private fun miniDoc(text: String, tags: Map<String, List<String>>): MiniDoc {
|
||||
val summary = text.lineSequence().map { it.trim() }.firstOrNull { it.isNotEmpty() }
|
||||
return MiniDoc(range = builtinRange(), raw = text, summary = summary, tags = tags)
|
||||
return MiniDoc.parse(builtinRange(), listOf(text), tags)
|
||||
}
|
||||
|
||||
private fun TypeDoc.toDisplayName(): String = when (this) {
|
||||
@@ -568,14 +571,20 @@ private fun buildStdlibDocs(): List<MiniDecl> {
|
||||
mod.classDoc(name = "Iterable", doc = StdlibInlineDocIndex.classDoc("Iterable") ?: "Helper operations for iterable collections.", bases = listOf(type("Obj"))) {
|
||||
fun md(name: String, fallback: String) = StdlibInlineDocIndex.methodDoc("Iterable", name) ?: fallback
|
||||
method(name = "filter", doc = md("filter", "Filter elements by predicate."), params = listOf(ParamDoc("predicate")), returns = type("lyng.Iterable"))
|
||||
method(name = "filterFlow", doc = md("filterFlow", "Filter elements by predicate and return a Flow."), params = listOf(ParamDoc("predicate")), returns = type("lyng.Flow"))
|
||||
method(name = "filterNotNull", doc = md("filterNotNull", "Filter non-null elements."), returns = type("lyng.List"))
|
||||
method(name = "drop", doc = md("drop", "Skip the first N elements."), params = listOf(ParamDoc("n", type("lyng.Int"))), returns = type("lyng.Iterable"))
|
||||
method(name = "first", doc = md("first", "Return the first element or throw if empty."))
|
||||
method(name = "last", doc = md("last", "Return the last element or throw if empty."))
|
||||
field(name = "first", doc = md("first", "Return the first element or throw if empty."))
|
||||
field(name = "last", doc = md("last", "Return the last element or throw if empty."))
|
||||
method(name = "findFirst", doc = md("findFirst", "Return the first matching element or throw."), params = listOf(ParamDoc("predicate")))
|
||||
method(name = "findFirstOrNull", doc = md("findFirstOrNull", "Return the first matching element or null."), params = listOf(ParamDoc("predicate")))
|
||||
method(name = "dropLast", doc = md("dropLast", "Drop the last N elements."), params = listOf(ParamDoc("n", type("lyng.Int"))), returns = type("lyng.Iterable"))
|
||||
method(name = "takeLast", doc = md("takeLast", "Take the last N elements."), params = listOf(ParamDoc("n", type("lyng.Int"))), returns = type("lyng.List"))
|
||||
method(name = "joinToString", doc = md("joinToString", "Join elements into a string with an optional separator and transformer."), params = listOf(ParamDoc("prefix", type("lyng.String")), ParamDoc("transformer")), returns = type("lyng.String"))
|
||||
method(name = "joinToString", doc = md("joinToString", "Join elements into a string with an optional separator and transformer."), params = listOf(ParamDoc("separator", type("lyng.String")), ParamDoc("transformer")), returns = type("lyng.String"))
|
||||
method(name = "any", doc = md("any", "Return true if any element matches the predicate."), params = listOf(ParamDoc("predicate")), returns = type("lyng.Bool"))
|
||||
method(name = "all", doc = md("all", "Return true if all elements match the predicate."), params = listOf(ParamDoc("predicate")), returns = type("lyng.Bool"))
|
||||
method(name = "forEach", doc = md("forEach", "Execute `action` for each element."), params = listOf(ParamDoc("action")))
|
||||
method(name = "count", doc = md("count", "Count elements matching the predicate."), params = listOf(ParamDoc("predicate")), returns = type("lyng.Int"))
|
||||
method(name = "sum", doc = md("sum", "Sum all elements; returns null for empty collections."), returns = type("lyng.Number", nullable = true))
|
||||
method(name = "sumOf", doc = md("sumOf", "Sum mapped values of elements; returns null for empty collections."), params = listOf(ParamDoc("f")))
|
||||
method(name = "minOf", doc = md("minOf", "Minimum of mapped values."), params = listOf(ParamDoc("lambda")))
|
||||
@@ -624,7 +633,7 @@ private fun buildStdlibDocs(): List<MiniDecl> {
|
||||
|
||||
mod.classDoc(name = "String", doc = StdlibInlineDocIndex.classDoc("String") ?: "String helpers.", bases = listOf(type("Obj"))) {
|
||||
// Only include inline-source method here; Kotlin-embedded methods are now documented via DocHelpers near definitions.
|
||||
method(name = "re", doc = StdlibInlineDocIndex.methodDoc("String", "re") ?: "Compile this string into a regular expression.", returns = type("lyng.Regex"))
|
||||
method(name = "re", doc = StdlibInlineDocIndex.methodDoc("String", "re") ?: "Compile this string into a regular expression.", params = listOf(ParamDoc("flags", type("lyng.String"))), returns = type("lyng.Regex"))
|
||||
}
|
||||
|
||||
// StackTraceEntry structure
|
||||
|
||||
@@ -33,6 +33,7 @@ data class CompletionItem(
|
||||
val kind: Kind,
|
||||
val tailText: String? = null,
|
||||
val typeText: String? = null,
|
||||
val priority: Double = 0.0,
|
||||
)
|
||||
|
||||
enum class Kind { Function, Class_, Enum, Value, Method, Field }
|
||||
@@ -73,6 +74,7 @@ object CompletionEngineLight {
|
||||
val word = DocLookupUtils.wordRangeAt(text, caret)
|
||||
val memberDot = DocLookupUtils.findDotLeft(text, word?.first ?: caret)
|
||||
if (memberDot != null) {
|
||||
val inferredCls = (DocLookupUtils.guessReturnClassFromMemberCallBeforeMini(mini, text, memberDot, imported, binding) ?: DocLookupUtils.guessReceiverClass(text, memberDot, imported, mini))
|
||||
// 0) Try chained member call return type inference
|
||||
DocLookupUtils.guessReturnClassFromMemberCallBeforeMini(mini, text, memberDot, imported, binding)?.let { cls ->
|
||||
offerMembersAdd(out, prefix, imported, cls, mini)
|
||||
@@ -107,7 +109,7 @@ object CompletionEngineLight {
|
||||
val locals = DocLookupUtils.extractLocalsAt(text, caret)
|
||||
for (name in locals) {
|
||||
if (name.startsWith(prefix, true)) {
|
||||
out.add(CompletionItem(name, Kind.Value))
|
||||
out.add(CompletionItem(name, Kind.Value, priority = 150.0))
|
||||
}
|
||||
}
|
||||
|
||||
@@ -168,17 +170,17 @@ object CompletionEngineLight {
|
||||
when (node) {
|
||||
is MiniFunDecl -> {
|
||||
for (p in node.params) {
|
||||
add(CompletionItem(p.name, Kind.Value, typeText = typeOf(p.type)))
|
||||
add(CompletionItem(p.name, Kind.Value, typeText = typeOf(p.type), priority = 200.0))
|
||||
}
|
||||
}
|
||||
is MiniClassDecl -> {
|
||||
// Propose constructor parameters (ctorFields)
|
||||
for (p in node.ctorFields) {
|
||||
add(CompletionItem(p.name, if (p.mutable) Kind.Value else Kind.Field, typeText = typeOf(p.type)))
|
||||
add(CompletionItem(p.name, if (p.mutable) Kind.Value else Kind.Field, typeText = typeOf(p.type), priority = 200.0))
|
||||
}
|
||||
// Propose class-level fields
|
||||
for (p in node.classFields) {
|
||||
add(CompletionItem(p.name, if (p.mutable) Kind.Value else Kind.Field, typeText = typeOf(p.type)))
|
||||
add(CompletionItem(p.name, if (p.mutable) Kind.Value else Kind.Field, typeText = typeOf(p.type), priority = 100.0))
|
||||
}
|
||||
// Process members (methods/fields)
|
||||
for (m in node.members) {
|
||||
@@ -189,10 +191,10 @@ object CompletionEngineLight {
|
||||
when (m) {
|
||||
is MiniMemberFunDecl -> {
|
||||
val params = m.params.joinToString(", ") { it.name }
|
||||
add(CompletionItem(m.name, Kind.Method, tailText = "(${params})", typeText = typeOf(m.returnType)))
|
||||
add(CompletionItem(m.name, Kind.Method, tailText = "(${params})", typeText = typeOf(m.returnType), priority = 100.0))
|
||||
}
|
||||
is MiniMemberValDecl -> {
|
||||
add(CompletionItem(m.name, if (m.mutable) Kind.Value else Kind.Field, typeText = typeOf(m.type)))
|
||||
add(CompletionItem(m.name, if (m.mutable) Kind.Value else Kind.Field, typeText = typeOf(m.type), priority = 100.0))
|
||||
}
|
||||
is MiniInitDecl -> {}
|
||||
}
|
||||
@@ -200,7 +202,7 @@ object CompletionEngineLight {
|
||||
}
|
||||
is MiniMemberFunDecl -> {
|
||||
for (p in node.params) {
|
||||
add(CompletionItem(p.name, Kind.Value, typeText = typeOf(p.type)))
|
||||
add(CompletionItem(p.name, Kind.Value, typeText = typeOf(p.type), priority = 200.0))
|
||||
}
|
||||
}
|
||||
else -> {}
|
||||
@@ -237,6 +239,9 @@ object CompletionEngineLight {
|
||||
fun addMembersOf(name: String, direct: Boolean) {
|
||||
val cls = classes[name] ?: return
|
||||
val target = if (direct) directMap else inheritedMap
|
||||
for (cf in cls.ctorFields + cls.classFields) {
|
||||
target.getOrPut(cf.name) { mutableListOf() }.add(DocLookupUtils.toMemberVal(cf))
|
||||
}
|
||||
for (m in cls.members) target.getOrPut(m.name) { mutableListOf() }.add(m)
|
||||
for (b in cls.bases) if (visited.add(b)) addMembersOf(b, false)
|
||||
}
|
||||
@@ -250,14 +255,22 @@ object CompletionEngineLight {
|
||||
"Array" -> listOf("Collection", "Iterable").forEach { if (visited.add(it)) addMembersOf(it, false) }
|
||||
}
|
||||
|
||||
fun emitGroup(map: LinkedHashMap<String, MutableList<MiniMemberDecl>>) {
|
||||
fun emitGroup(map: LinkedHashMap<String, MutableList<MiniMemberDecl>>, groupPriority: Double) {
|
||||
for (name in map.keys.sortedBy { it.lowercase() }) {
|
||||
val variants = map[name] ?: continue
|
||||
// Prefer a method with a known return type; else any method; else first variant
|
||||
// Choose a representative for display:
|
||||
// 1) Prefer a method with return type AND parameters
|
||||
// 2) Prefer a method with parameters
|
||||
// 3) Prefer a method with return type
|
||||
// 4) Else any method
|
||||
// 5) Else the first variant
|
||||
val rep =
|
||||
variants.asSequence()
|
||||
.filterIsInstance<MiniMemberFunDecl>()
|
||||
.firstOrNull { it.returnType != null }
|
||||
variants.asSequence().filterIsInstance<MiniMemberFunDecl>()
|
||||
.firstOrNull { it.returnType != null && it.params.isNotEmpty() }
|
||||
?: variants.asSequence().filterIsInstance<MiniMemberFunDecl>()
|
||||
.firstOrNull { it.params.isNotEmpty() }
|
||||
?: variants.asSequence().filterIsInstance<MiniMemberFunDecl>()
|
||||
.firstOrNull { it.returnType != null }
|
||||
?: variants.firstOrNull { it is MiniMemberFunDecl }
|
||||
?: variants.first()
|
||||
when (rep) {
|
||||
@@ -265,7 +278,7 @@ object CompletionEngineLight {
|
||||
val params = rep.params.joinToString(", ") { it.name }
|
||||
val extra = variants.count { it is MiniMemberFunDecl } - 1
|
||||
val ov = if (extra > 0) " (+$extra overloads)" else ""
|
||||
val ci = CompletionItem(name, Kind.Method, tailText = "(${params})$ov", typeText = typeOf(rep.returnType))
|
||||
val ci = CompletionItem(name, Kind.Method, tailText = "(${params})$ov", typeText = typeOf(rep.returnType), priority = groupPriority)
|
||||
if (ci.name.startsWith(prefix, true)) out += ci
|
||||
}
|
||||
is MiniMemberValDecl -> {
|
||||
@@ -273,7 +286,7 @@ object CompletionEngineLight {
|
||||
val chosen = variants.asSequence()
|
||||
.filterIsInstance<MiniMemberValDecl>()
|
||||
.firstOrNull { it.type != null } ?: rep
|
||||
val ci = CompletionItem(name, Kind.Field, typeText = typeOf(chosen.type))
|
||||
val ci = CompletionItem(name, Kind.Field, typeText = typeOf(chosen.type), priority = groupPriority)
|
||||
if (ci.name.startsWith(prefix, true)) out += ci
|
||||
}
|
||||
is MiniInitDecl -> {}
|
||||
@@ -281,8 +294,8 @@ object CompletionEngineLight {
|
||||
}
|
||||
}
|
||||
|
||||
emitGroup(directMap)
|
||||
emitGroup(inheritedMap)
|
||||
emitGroup(directMap, 100.0)
|
||||
emitGroup(inheritedMap, 0.0)
|
||||
|
||||
// Supplement with extension members (both stdlib and local)
|
||||
run {
|
||||
@@ -296,22 +309,22 @@ object CompletionEngineLight {
|
||||
val ci = when (m) {
|
||||
is MiniMemberFunDecl -> {
|
||||
val params = m.params.joinToString(", ") { it.name }
|
||||
CompletionItem(name, Kind.Method, tailText = "(${params})", typeText = typeOf(m.returnType))
|
||||
CompletionItem(name, Kind.Method, tailText = "(${params})", typeText = typeOf(m.returnType), priority = 50.0)
|
||||
}
|
||||
is MiniFunDecl -> {
|
||||
val params = m.params.joinToString(", ") { it.name }
|
||||
CompletionItem(name, Kind.Method, tailText = "(${params})", typeText = typeOf(m.returnType))
|
||||
CompletionItem(name, Kind.Method, tailText = "(${params})", typeText = typeOf(m.returnType), priority = 50.0)
|
||||
}
|
||||
is MiniMemberValDecl -> CompletionItem(name, Kind.Field, typeText = typeOf(m.type))
|
||||
is MiniValDecl -> CompletionItem(name, Kind.Field, typeText = typeOf(m.type))
|
||||
else -> CompletionItem(name, Kind.Method, tailText = "()", typeText = null)
|
||||
is MiniMemberValDecl -> CompletionItem(name, Kind.Field, typeText = typeOf(m.type), priority = 50.0)
|
||||
is MiniValDecl -> CompletionItem(name, Kind.Field, typeText = typeOf(m.type), priority = 50.0)
|
||||
else -> CompletionItem(name, Kind.Method, tailText = "()", typeText = null, priority = 50.0)
|
||||
}
|
||||
if (ci.name.startsWith(prefix, true)) {
|
||||
out += ci
|
||||
already.add(name)
|
||||
}
|
||||
} else {
|
||||
val ci = CompletionItem(name, Kind.Method, tailText = "()", typeText = null)
|
||||
val ci = CompletionItem(name, Kind.Method, tailText = "()", typeText = null, priority = 50.0)
|
||||
if (ci.name.startsWith(prefix, true)) {
|
||||
out += ci
|
||||
already.add(name)
|
||||
@@ -335,16 +348,9 @@ object CompletionEngineLight {
|
||||
}
|
||||
}
|
||||
|
||||
private fun typeOf(t: MiniTypeRef?): String = when (t) {
|
||||
null -> ""
|
||||
is MiniTypeName -> t.segments.lastOrNull()?.name?.let { ": $it" } ?: ""
|
||||
is MiniGenericType -> {
|
||||
val base = typeOf(t.base).removePrefix(": ")
|
||||
val args = t.args.joinToString(",") { typeOf(it).removePrefix(": ") }
|
||||
": ${base}<${args}>"
|
||||
}
|
||||
is MiniFunctionType -> ": (fn)"
|
||||
is MiniTypeVar -> ": ${t.name}"
|
||||
private fun typeOf(t: MiniTypeRef?): String {
|
||||
val s = DocLookupUtils.typeOf(t)
|
||||
return if (s.isEmpty()) "" else ": $s"
|
||||
}
|
||||
|
||||
// Note: we intentionally skip "params in scope" in the isolated engine to avoid PSI/offset mapping.
|
||||
|
||||
@@ -78,6 +78,11 @@ object DocLookupUtils {
|
||||
}
|
||||
|
||||
for (m in members) {
|
||||
if (m is MiniMemberFunDecl) {
|
||||
for (p in m.params) {
|
||||
if (matches(p.nameStart, p.name.length)) return p.name to "Parameter"
|
||||
}
|
||||
}
|
||||
if (matches(m.nameStart, m.name.length)) {
|
||||
val kind = when (m) {
|
||||
is MiniMemberFunDecl -> "Function"
|
||||
@@ -91,6 +96,19 @@ object DocLookupUtils {
|
||||
return null
|
||||
}
|
||||
|
||||
fun findEnclosingClass(mini: MiniScript, offset: Int): MiniClassDecl? {
|
||||
val src = mini.range.start.source
|
||||
return mini.declarations.filterIsInstance<MiniClassDecl>()
|
||||
.filter {
|
||||
val start = src.offsetOf(it.range.start)
|
||||
val end = src.offsetOf(it.range.end)
|
||||
offset in start..end
|
||||
}
|
||||
.minByOrNull {
|
||||
src.offsetOf(it.range.end) - src.offsetOf(it.range.start)
|
||||
}
|
||||
}
|
||||
|
||||
fun findTypeByRange(mini: MiniScript?, name: String, startOffset: Int, text: String? = null, imported: List<String>? = null): MiniTypeRef? {
|
||||
if (mini == null) return null
|
||||
val src = mini.range.start.source
|
||||
@@ -113,12 +131,18 @@ object DocLookupUtils {
|
||||
|
||||
if (d is MiniClassDecl) {
|
||||
for (m in d.members) {
|
||||
if (m is MiniMemberFunDecl) {
|
||||
for (p in m.params) {
|
||||
if (p.name == name && matches(p.nameStart, p.name.length)) return p.type
|
||||
}
|
||||
}
|
||||
if (m.name == name && matches(m.nameStart, m.name.length)) {
|
||||
return when (m) {
|
||||
is MiniMemberFunDecl -> m.returnType
|
||||
is MiniMemberValDecl -> m.type ?: if (text != null && imported != null) {
|
||||
inferTypeRefFromInitRange(m.initRange, m.nameStart, text, imported, mini)
|
||||
} else null
|
||||
|
||||
else -> null
|
||||
}
|
||||
}
|
||||
@@ -222,10 +246,14 @@ object DocLookupUtils {
|
||||
val rep = list.first()
|
||||
val bases = LinkedHashSet<String>()
|
||||
val members = LinkedHashMap<String, MutableList<MiniMemberDecl>>()
|
||||
val ctorFields = LinkedHashMap<String, MiniCtorField>()
|
||||
val classFields = LinkedHashMap<String, MiniCtorField>()
|
||||
var doc: MiniDoc? = null
|
||||
for (c in list) {
|
||||
bases.addAll(c.bases)
|
||||
if (doc == null && c.doc != null && c.doc.raw.isNotBlank()) doc = c.doc
|
||||
for (cf in c.ctorFields) ctorFields[cf.name] = cf
|
||||
for (cf in c.classFields) classFields[cf.name] = cf
|
||||
for (m in c.members) {
|
||||
// Group by name to keep overloads together
|
||||
members.getOrPut(m.name) { mutableListOf() }.add(m)
|
||||
@@ -238,8 +266,8 @@ object DocLookupUtils {
|
||||
name = rep.name,
|
||||
bases = bases.toList(),
|
||||
bodyRange = rep.bodyRange,
|
||||
ctorFields = rep.ctorFields,
|
||||
classFields = rep.classFields,
|
||||
ctorFields = ctorFields.values.toList(),
|
||||
classFields = classFields.values.toList(),
|
||||
doc = doc,
|
||||
nameStart = rep.nameStart,
|
||||
members = mergedMembers
|
||||
@@ -257,6 +285,18 @@ object DocLookupUtils {
|
||||
return result
|
||||
}
|
||||
|
||||
internal fun toMemberVal(cf: MiniCtorField): MiniMemberValDecl = MiniMemberValDecl(
|
||||
range = MiniRange(cf.nameStart, cf.nameStart),
|
||||
name = cf.name,
|
||||
mutable = cf.mutable,
|
||||
type = cf.type,
|
||||
initRange = null,
|
||||
doc = null,
|
||||
nameStart = cf.nameStart,
|
||||
isStatic = false,
|
||||
isExtern = false
|
||||
)
|
||||
|
||||
fun resolveMemberWithInheritance(importedModules: List<String>, className: String, member: String, localMini: MiniScript? = null): Pair<String, MiniNamedDecl>? {
|
||||
val classes = aggregateClasses(importedModules, localMini)
|
||||
fun dfs(name: String, visited: MutableSet<String>): Pair<String, MiniNamedDecl>? {
|
||||
@@ -264,15 +304,26 @@ object DocLookupUtils {
|
||||
val cls = classes[name]
|
||||
if (cls != null) {
|
||||
cls.members.firstOrNull { it.name == member }?.let { return name to it }
|
||||
cls.ctorFields.firstOrNull { it.name == member }?.let { return name to toMemberVal(it) }
|
||||
cls.classFields.firstOrNull { it.name == member }?.let { return name to toMemberVal(it) }
|
||||
for (baseName in cls.bases) {
|
||||
dfs(baseName, visited)?.let { return it }
|
||||
}
|
||||
}
|
||||
// Check for local extensions in this class or bases
|
||||
// 1) local extensions in this class or bases
|
||||
localMini?.declarations?.firstOrNull { d ->
|
||||
(d is MiniFunDecl && d.receiver != null && simpleClassNameOf(d.receiver) == name && d.name == member) ||
|
||||
(d is MiniValDecl && d.receiver != null && simpleClassNameOf(d.receiver) == name && d.name == member)
|
||||
}?.let { return name to it }
|
||||
(d is MiniValDecl && d.receiver != null && simpleClassNameOf(d.receiver) == name && d.name == member)
|
||||
}?.let { return name to it as MiniNamedDecl }
|
||||
|
||||
// 2) built-in extensions from BuiltinDocRegistry
|
||||
for (mod in importedModules) {
|
||||
val decls = BuiltinDocRegistry.docsForModule(mod)
|
||||
decls.firstOrNull { d ->
|
||||
(d is MiniFunDecl && d.receiver != null && simpleClassNameOf(d.receiver) == name && d.name == member) ||
|
||||
(d is MiniValDecl && d.receiver != null && simpleClassNameOf(d.receiver) == name && d.name == member)
|
||||
}?.let { return name to it as MiniNamedDecl }
|
||||
}
|
||||
|
||||
return null
|
||||
}
|
||||
@@ -636,6 +687,12 @@ object DocLookupUtils {
|
||||
val identRange = wordRangeAt(text, i + 1)
|
||||
if (identRange != null) {
|
||||
val ident = text.substring(identRange.first, identRange.second)
|
||||
|
||||
// 3a) Handle plain "this"
|
||||
if (ident == "this" && mini != null) {
|
||||
findEnclosingClass(mini, identRange.first)?.let { return it.name }
|
||||
}
|
||||
|
||||
// if it's "as Type", we want Type
|
||||
var k = prevNonWs(text, identRange.first - 1)
|
||||
if (k >= 1 && text[k] == 's' && text[k - 1] == 'a' && (k - 1 == 0 || !text[k - 2].isLetterOrDigit())) {
|
||||
@@ -970,6 +1027,17 @@ object DocLookupUtils {
|
||||
is MiniTypeVar -> null
|
||||
}
|
||||
|
||||
fun typeOf(t: MiniTypeRef?): String = when (t) {
|
||||
is MiniTypeName -> t.segments.joinToString(".") { it.name } + (if (t.nullable) "?" else "")
|
||||
is MiniGenericType -> typeOf(t.base) + "<" + t.args.joinToString(", ") { typeOf(it) } + ">" + (if (t.nullable) "?" else "")
|
||||
is MiniFunctionType -> {
|
||||
val r = t.receiver?.let { typeOf(it) + "." } ?: ""
|
||||
r + "(" + t.params.joinToString(", ") { typeOf(it) } + ") -> " + typeOf(t.returnType) + (if (t.nullable) "?" else "")
|
||||
}
|
||||
is MiniTypeVar -> t.name + (if (t.nullable) "?" else "")
|
||||
null -> ""
|
||||
}
|
||||
|
||||
fun findDotLeft(text: String, offset: Int): Int? {
|
||||
var i = (offset - 1).coerceAtLeast(0)
|
||||
while (i >= 0 && text[i].isWhitespace()) i--
|
||||
|
||||
@@ -39,7 +39,56 @@ data class MiniDoc(
|
||||
val raw: String,
|
||||
val summary: String?,
|
||||
val tags: Map<String, List<String>> = emptyMap()
|
||||
)
|
||||
) {
|
||||
companion object {
|
||||
fun parse(range: MiniRange, lines: Iterable<String>, extraTags: Map<String, List<String>> = emptyMap()): MiniDoc {
|
||||
val parsedTags = mutableMapOf<String, MutableList<String>>()
|
||||
var currentTag: String? = null
|
||||
val currentContent = StringBuilder()
|
||||
|
||||
fun flush() {
|
||||
currentTag?.let { tag ->
|
||||
parsedTags.getOrPut(tag) { mutableListOf() }.add(currentContent.toString().trim())
|
||||
}
|
||||
currentContent.setLength(0)
|
||||
}
|
||||
|
||||
val descriptionLines = mutableListOf<String>()
|
||||
var inTags = false
|
||||
|
||||
for (rawLine in lines) {
|
||||
for (line in rawLine.lines()) {
|
||||
val trimmed = line.trim()
|
||||
if (trimmed.startsWith("@")) {
|
||||
inTags = true
|
||||
flush()
|
||||
val parts = trimmed.substring(1).split(Regex("\\s+"), 2)
|
||||
currentTag = parts[0]
|
||||
currentContent.append(parts.getOrNull(1) ?: "")
|
||||
} else {
|
||||
if (inTags) {
|
||||
if (currentContent.isNotEmpty()) currentContent.append("\n")
|
||||
currentContent.append(line)
|
||||
} else {
|
||||
descriptionLines.add(line)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
flush()
|
||||
|
||||
val raw = descriptionLines.joinToString("\n").trimEnd()
|
||||
val summary = raw.lines().firstOrNull { it.isNotBlank() }?.trim()
|
||||
|
||||
val finalTags = parsedTags.toMutableMap()
|
||||
extraTags.forEach { (k, v) ->
|
||||
finalTags.getOrPut(k) { mutableListOf() }.addAll(v)
|
||||
}
|
||||
|
||||
return MiniDoc(range, raw, summary, finalTags)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
sealed interface MiniNode { val range: MiniRange }
|
||||
|
||||
@@ -87,6 +136,7 @@ sealed interface MiniNamedDecl : MiniNode {
|
||||
// Start position of the declaration name identifier in source; end can be derived as start + name.length
|
||||
val nameStart: Pos
|
||||
val isExtern: Boolean
|
||||
val isStatic: Boolean
|
||||
}
|
||||
|
||||
sealed interface MiniDecl : MiniNamedDecl
|
||||
@@ -114,7 +164,8 @@ data class MiniFunDecl(
|
||||
override val doc: MiniDoc?,
|
||||
override val nameStart: Pos,
|
||||
val receiver: MiniTypeRef? = null,
|
||||
override val isExtern: Boolean = false
|
||||
override val isExtern: Boolean = false,
|
||||
override val isStatic: Boolean = false,
|
||||
) : MiniDecl
|
||||
|
||||
data class MiniValDecl(
|
||||
@@ -126,7 +177,8 @@ data class MiniValDecl(
|
||||
override val doc: MiniDoc?,
|
||||
override val nameStart: Pos,
|
||||
val receiver: MiniTypeRef? = null,
|
||||
override val isExtern: Boolean = false
|
||||
override val isExtern: Boolean = false,
|
||||
override val isStatic: Boolean = false,
|
||||
) : MiniDecl
|
||||
|
||||
data class MiniClassDecl(
|
||||
@@ -141,6 +193,7 @@ data class MiniClassDecl(
|
||||
// Built-in extension: list of member declarations (functions and fields)
|
||||
val members: List<MiniMemberDecl> = emptyList(),
|
||||
override val isExtern: Boolean = false,
|
||||
override val isStatic: Boolean = false,
|
||||
val isObject: Boolean = false
|
||||
) : MiniDecl
|
||||
|
||||
@@ -150,7 +203,9 @@ data class MiniEnumDecl(
|
||||
val entries: List<String>,
|
||||
override val doc: MiniDoc?,
|
||||
override val nameStart: Pos,
|
||||
override val isExtern: Boolean = false
|
||||
override val isExtern: Boolean = false,
|
||||
override val isStatic: Boolean = false,
|
||||
val entryPositions: List<Pos> = emptyList()
|
||||
) : MiniDecl
|
||||
|
||||
data class MiniCtorField(
|
||||
@@ -175,7 +230,7 @@ data class MiniIdentifier(
|
||||
|
||||
// --- Class member declarations (for built-in/registry docs) ---
|
||||
sealed interface MiniMemberDecl : MiniNamedDecl {
|
||||
val isStatic: Boolean
|
||||
override val isStatic: Boolean
|
||||
}
|
||||
|
||||
data class MiniMemberFunDecl(
|
||||
@@ -319,7 +374,7 @@ class MiniAstBuilder : MiniAstSink {
|
||||
returnType = attach.returnType,
|
||||
doc = attach.doc,
|
||||
nameStart = attach.nameStart,
|
||||
isStatic = false, // TODO: track static if needed
|
||||
isStatic = attach.isStatic,
|
||||
isExtern = attach.isExtern,
|
||||
body = attach.body
|
||||
)
|
||||
@@ -359,7 +414,7 @@ class MiniAstBuilder : MiniAstSink {
|
||||
initRange = attach.initRange,
|
||||
doc = attach.doc,
|
||||
nameStart = attach.nameStart,
|
||||
isStatic = false, // TODO: track static if needed
|
||||
isStatic = attach.isStatic,
|
||||
isExtern = attach.isExtern
|
||||
)
|
||||
// Duplicates for vals are rare but possible if Compiler calls it twice
|
||||
|
||||
@@ -106,6 +106,34 @@ open class ObjClass(
|
||||
val classId: Long = ClassIdGen.nextId()
|
||||
var layoutVersion: Int = 0
|
||||
|
||||
private val mangledNameCache = mutableMapOf<String, String>()
|
||||
fun mangledName(name: String): String = mangledNameCache.getOrPut(name) { "$className::$name" }
|
||||
|
||||
/**
|
||||
* Map of public member names to their effective storage keys in instanceScope.objects.
|
||||
* This is pre-calculated to avoid MRO traversal and string concatenation during common access.
|
||||
*/
|
||||
val publicMemberResolution: Map<String, String> by lazy {
|
||||
val res = mutableMapOf<String, String>()
|
||||
// Traverse MRO in REVERSED order so that child classes override parent classes in the map.
|
||||
for (cls in mro.reversed()) {
|
||||
if (cls.className == "Obj") continue
|
||||
for ((name, rec) in cls.members) {
|
||||
if (rec.visibility == Visibility.Public) {
|
||||
val key = if (rec.type == ObjRecord.Type.Field || rec.type == ObjRecord.Type.Delegated) cls.mangledName(name) else name
|
||||
res[name] = key
|
||||
}
|
||||
}
|
||||
cls.classScope?.objects?.forEach { (name, rec) ->
|
||||
if (rec.visibility == Visibility.Public && (rec.value is Statement || rec.type == ObjRecord.Type.Delegated)) {
|
||||
val key = if (rec.type == ObjRecord.Type.Delegated) cls.mangledName(name) else name
|
||||
res[name] = key
|
||||
}
|
||||
}
|
||||
}
|
||||
res
|
||||
}
|
||||
|
||||
val classNameObj by lazy { ObjString(className) }
|
||||
|
||||
var constructorMeta: ArgsDeclaration? = null
|
||||
@@ -242,6 +270,43 @@ open class ObjClass(
|
||||
return instance
|
||||
}
|
||||
|
||||
/** Pre-calculated template for instanceScope.objects. */
|
||||
private val instanceObjectsTemplate: Map<String, ObjRecord> by lazy {
|
||||
val res = mutableMapOf<String, ObjRecord>()
|
||||
for (cls in mro) {
|
||||
// 1) members-defined methods and fields
|
||||
for ((k, v) in cls.members) {
|
||||
if (!v.isAbstract && (v.value is Statement || v.type == ObjRecord.Type.Delegated || v.type == ObjRecord.Type.Field)) {
|
||||
val key = if (v.visibility == Visibility.Private || v.type == ObjRecord.Type.Field || v.type == ObjRecord.Type.Delegated) cls.mangledName(k) else k
|
||||
if (!res.containsKey(key)) {
|
||||
res[key] = v
|
||||
}
|
||||
}
|
||||
}
|
||||
// 2) class-scope members registered during class-body execution
|
||||
cls.classScope?.objects?.forEach { (k, rec) ->
|
||||
// ONLY copy methods and delegated members from class scope to instance scope.
|
||||
// Fields in class scope are static fields and must NOT be per-instance.
|
||||
if (!rec.isAbstract && (rec.value is Statement || rec.type == ObjRecord.Type.Delegated)) {
|
||||
val key = if (rec.visibility == Visibility.Private || rec.type == ObjRecord.Type.Delegated) cls.mangledName(k) else k
|
||||
// if not already present, copy reference for dispatch
|
||||
if (!res.containsKey(key)) {
|
||||
res[key] = rec
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
res
|
||||
}
|
||||
|
||||
private val templateMethods: Map<String, ObjRecord> by lazy {
|
||||
instanceObjectsTemplate.filter { it.value.type == ObjRecord.Type.Fun }
|
||||
}
|
||||
|
||||
private val templateOthers: List<Pair<String, ObjRecord>> by lazy {
|
||||
instanceObjectsTemplate.filter { it.value.type != ObjRecord.Type.Fun }.toList()
|
||||
}
|
||||
|
||||
/**
|
||||
* Create an instance of this class and initialize its [ObjInstance.instanceScope] with
|
||||
* methods. Does NOT run initializers or constructors.
|
||||
@@ -257,28 +322,9 @@ open class ObjClass(
|
||||
// Expose instance methods (and other callable members) directly in the instance scope for fast lookup
|
||||
// This mirrors Obj.autoInstanceScope behavior for ad-hoc scopes and makes fb.method() resolution robust
|
||||
|
||||
for (cls in mro) {
|
||||
// 1) members-defined methods and fields
|
||||
for ((k, v) in cls.members) {
|
||||
if (!v.isAbstract && (v.value is Statement || v.type == ObjRecord.Type.Delegated || v.type == ObjRecord.Type.Field)) {
|
||||
val key = if (v.visibility == Visibility.Private || v.type == ObjRecord.Type.Field || v.type == ObjRecord.Type.Delegated) "${cls.className}::$k" else k
|
||||
if (!instance.instanceScope.objects.containsKey(key)) {
|
||||
instance.instanceScope.objects[key] = if (v.type == ObjRecord.Type.Fun) v else v.copy()
|
||||
}
|
||||
}
|
||||
}
|
||||
// 2) class-scope members registered during class-body execution
|
||||
cls.classScope?.objects?.forEach { (k, rec) ->
|
||||
// ONLY copy methods and delegated members from class scope to instance scope.
|
||||
// Fields in class scope are static fields and must NOT be per-instance.
|
||||
if (!rec.isAbstract && (rec.value is Statement || rec.type == ObjRecord.Type.Delegated)) {
|
||||
val key = if (rec.visibility == Visibility.Private || rec.type == ObjRecord.Type.Delegated) "${cls.className}::$k" else k
|
||||
// if not already present, copy reference for dispatch
|
||||
if (!instance.instanceScope.objects.containsKey(key)) {
|
||||
instance.instanceScope.objects[key] = if (rec.type == ObjRecord.Type.Fun) rec else rec.copy()
|
||||
}
|
||||
}
|
||||
}
|
||||
instance.instanceScope.objects.putAll(templateMethods)
|
||||
for (p in templateOthers) {
|
||||
instance.instanceScope.objects[p.first] = p.second.copy()
|
||||
}
|
||||
return instance
|
||||
}
|
||||
@@ -327,7 +373,7 @@ open class ObjClass(
|
||||
for (p in meta.params) {
|
||||
val rec = instance.instanceScope.objects[p.name]
|
||||
if (rec != null) {
|
||||
val mangled = "${c.className}::${p.name}"
|
||||
val mangled = c.mangledName(p.name)
|
||||
// Always point the mangled name to the current record to keep writes consistent
|
||||
// across re-bindings
|
||||
instance.instanceScope.objects[mangled] = rec
|
||||
@@ -361,7 +407,7 @@ open class ObjClass(
|
||||
for (p in meta.params) {
|
||||
val rec = instance.instanceScope.objects[p.name]
|
||||
if (rec != null) {
|
||||
val mangled = "${c.className}::${p.name}"
|
||||
val mangled = c.mangledName(p.name)
|
||||
instance.instanceScope.objects[mangled] = rec
|
||||
}
|
||||
}
|
||||
|
||||
@@ -72,10 +72,11 @@ open class ObjException(
|
||||
val l = getStackTrace().list
|
||||
return buildString {
|
||||
append(message.value)
|
||||
for( t in l)
|
||||
for (t in l)
|
||||
append("\n\tat ${t.toString(scope)}")
|
||||
}
|
||||
}
|
||||
|
||||
override suspend fun defaultToString(scope: Scope): ObjString {
|
||||
val at = getStackTrace().list.firstOrNull()?.toString(scope)
|
||||
?: ObjString("(unknown)")
|
||||
@@ -100,21 +101,23 @@ open class ObjException(
|
||||
while (s != null) {
|
||||
val pos = s.pos
|
||||
if (pos != lastPos && !pos.currentLine.isEmpty()) {
|
||||
if (maybeCls != null) {
|
||||
result.list += maybeCls.callWithArgs(
|
||||
scope,
|
||||
pos.source.objSourceName,
|
||||
ObjInt(pos.line.toLong()),
|
||||
ObjInt(pos.column.toLong()),
|
||||
ObjString(pos.currentLine)
|
||||
)
|
||||
} else {
|
||||
// Fallback textual entry if StackTraceEntry class is not available in this scope
|
||||
result.list += ObjString("${pos.source.objSourceName}:${pos.line}:${pos.column}: ${pos.currentLine}")
|
||||
if( (lastPos == null || (lastPos.source != pos.source || lastPos.line != pos.line)) ) {
|
||||
if (maybeCls != null) {
|
||||
result.list += maybeCls.callWithArgs(
|
||||
scope,
|
||||
pos.source.objSourceName,
|
||||
ObjInt(pos.line.toLong()),
|
||||
ObjInt(pos.column.toLong()),
|
||||
ObjString(pos.currentLine)
|
||||
)
|
||||
} else {
|
||||
// Fallback textual entry if StackTraceEntry class is not available in this scope
|
||||
result.list += ObjString("#${pos.source.objSourceName}:${pos.line+1}:${pos.column+1}: ${pos.currentLine}")
|
||||
}
|
||||
lastPos = pos
|
||||
}
|
||||
}
|
||||
s = s.parent
|
||||
lastPos = pos
|
||||
}
|
||||
return result
|
||||
}
|
||||
@@ -129,7 +132,9 @@ open class ObjException(
|
||||
|
||||
override suspend fun callOn(scope: Scope): Obj {
|
||||
val message = scope.args.getOrNull(0)?.toString(scope) ?: ObjString(name)
|
||||
return ObjException(this, scope, message)
|
||||
val ex = ObjException(this, scope, message)
|
||||
ex.getStackTrace()
|
||||
return ex
|
||||
}
|
||||
|
||||
override fun toString(): String = name
|
||||
@@ -337,8 +342,8 @@ fun Obj.isLyngException(): Boolean = isInstanceOf("Exception")
|
||||
/**
|
||||
* Get the exception message.
|
||||
*/
|
||||
suspend fun Obj.getLyngExceptionMessage(scope: Scope?=null): String {
|
||||
require( this.isLyngException() )
|
||||
suspend fun Obj.getLyngExceptionMessage(scope: Scope? = null): String {
|
||||
require(this.isLyngException())
|
||||
val s = scope ?: Script.newScope()
|
||||
return invokeInstanceMethod(s, "message").toString(s).value
|
||||
}
|
||||
@@ -354,18 +359,18 @@ suspend fun Obj.getLyngExceptionMessage(scope: Scope?=null): String {
|
||||
* The stack trace details each frame using indentation for clarity.
|
||||
* @throws IllegalArgumentException if the object is not a Lyng exception.
|
||||
*/
|
||||
suspend fun Obj.getLyngExceptionMessageWithStackTrace(scope: Scope?=null): String {
|
||||
require( this.isLyngException() )
|
||||
suspend fun Obj.getLyngExceptionMessageWithStackTrace(scope: Scope? = null,showDetails:Boolean=true): String {
|
||||
require(this.isLyngException())
|
||||
val s = scope ?: Script.newScope()
|
||||
val msg = getLyngExceptionMessage(s)
|
||||
val trace = getLyngExceptionStackTrace(s)
|
||||
var at = "unknown"
|
||||
val stack = if( !trace.list.isEmpty() ) {
|
||||
// var firstLine = true
|
||||
val stack = if (!trace.list.isEmpty()) {
|
||||
val first = trace.list[0]
|
||||
at = (first.readField(s, "at").value as ObjString).value
|
||||
"\n" + trace.list.map { " at " + it.toString(s).value }.joinToString("\n")
|
||||
}
|
||||
else ""
|
||||
} else ""
|
||||
return "$at: $msg$stack"
|
||||
}
|
||||
|
||||
@@ -390,7 +395,7 @@ suspend fun Obj.getLyngExceptionString(scope: Scope): String =
|
||||
/**
|
||||
* Rethrow this object as a Kotlin [ExecutionError] if it's an exception.
|
||||
*/
|
||||
suspend fun Obj.raiseAsExecutionError(scope: Scope?=null): Nothing {
|
||||
suspend fun Obj.raiseAsExecutionError(scope: Scope? = null): Nothing {
|
||||
if (this is ObjException) raise()
|
||||
val sc = scope ?: Script.newScope()
|
||||
val msg = getLyngExceptionMessage(sc)
|
||||
|
||||
@@ -34,6 +34,18 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
|
||||
override suspend fun readField(scope: Scope, name: String): ObjRecord {
|
||||
val caller = scope.currentClassCtx
|
||||
|
||||
// Fast path for public members when outside any class context
|
||||
if (caller == null) {
|
||||
objClass.publicMemberResolution[name]?.let { key ->
|
||||
instanceScope.objects[key]?.let { rec ->
|
||||
// Directly return fields to bypass resolveRecord overhead
|
||||
if ((rec.type == ObjRecord.Type.Field || rec.type == ObjRecord.Type.ConstructorField) && !rec.isAbstract)
|
||||
return rec
|
||||
return resolveRecord(scope, rec, name, rec.declaringClass)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 0. Private mangled of current class context
|
||||
caller?.let { c ->
|
||||
// Check for private methods/properties
|
||||
@@ -43,7 +55,7 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
|
||||
}
|
||||
}
|
||||
// Check for private fields (stored in instanceScope)
|
||||
val mangled = "${c.className}::$name"
|
||||
val mangled = c.mangledName(name)
|
||||
instanceScope.objects[mangled]?.let { rec ->
|
||||
if (rec.visibility == Visibility.Private) {
|
||||
return resolveRecord(scope, rec, name, c)
|
||||
@@ -54,7 +66,7 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
|
||||
// 1. MRO mangled storage
|
||||
for (cls in objClass.mro) {
|
||||
if (cls.className == "Obj") break
|
||||
val mangled = "${cls.className}::$name"
|
||||
val mangled = cls.mangledName(name)
|
||||
instanceScope.objects[mangled]?.let { rec ->
|
||||
if ((scope.thisObj === this && caller != null) || canAccessMember(rec.visibility, cls, caller)) {
|
||||
return resolveRecord(scope, rec, name, cls)
|
||||
@@ -79,11 +91,11 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
|
||||
if (obj.type.isArgument) return super.resolveRecord(scope, obj, name, decl)
|
||||
if (obj.type == ObjRecord.Type.Delegated) {
|
||||
val d = decl ?: obj.declaringClass
|
||||
val storageName = "${d?.className}::$name"
|
||||
val storageName = d?.mangledName(name) ?: name
|
||||
var del = instanceScope[storageName]?.delegate ?: obj.delegate
|
||||
if (del == null) {
|
||||
for (c in objClass.mro) {
|
||||
del = instanceScope["${c.className}::$name"]?.delegate
|
||||
del = instanceScope[c.mangledName(name)]?.delegate
|
||||
if (del != null) break
|
||||
}
|
||||
}
|
||||
@@ -97,7 +109,7 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
|
||||
var targetRec = obj
|
||||
val d = decl ?: obj.declaringClass
|
||||
if (d != null) {
|
||||
val mangled = "${d.className}::$name"
|
||||
val mangled = d.mangledName(name)
|
||||
instanceScope.objects[mangled]?.let {
|
||||
targetRec = it
|
||||
}
|
||||
@@ -120,6 +132,24 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
|
||||
willMutate(scope)
|
||||
val caller = scope.currentClassCtx
|
||||
|
||||
// Fast path for public members when outside any class context
|
||||
if (caller == null) {
|
||||
objClass.publicMemberResolution[name]?.let { key ->
|
||||
instanceScope.objects[key]?.let { rec ->
|
||||
if (rec.effectiveWriteVisibility == Visibility.Public) {
|
||||
// Skip property/delegated overhead if it's a plain mutable field
|
||||
if (rec.type == ObjRecord.Type.Field && rec.isMutable && !rec.isAbstract) {
|
||||
if (rec.value.assign(scope, newValue) == null)
|
||||
rec.value = newValue
|
||||
return
|
||||
}
|
||||
updateRecord(scope, rec, name, newValue, rec.declaringClass)
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 0. Private mangled of current class context
|
||||
caller?.let { c ->
|
||||
// Check for private methods/properties
|
||||
@@ -130,7 +160,7 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
|
||||
}
|
||||
}
|
||||
// Check for private fields (stored in instanceScope)
|
||||
val mangled = "${c.className}::$name"
|
||||
val mangled = c.mangledName(name)
|
||||
instanceScope.objects[mangled]?.let { rec ->
|
||||
if (rec.visibility == Visibility.Private) {
|
||||
updateRecord(scope, rec, name, newValue, c)
|
||||
@@ -142,7 +172,7 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
|
||||
// 1. MRO mangled storage
|
||||
for (cls in objClass.mro) {
|
||||
if (cls.className == "Obj") break
|
||||
val mangled = "${cls.className}::$name"
|
||||
val mangled = cls.mangledName(name)
|
||||
instanceScope.objects[mangled]?.let { rec ->
|
||||
if ((scope.thisObj === this && caller != null) || canAccessMember(rec.effectiveWriteVisibility, cls, caller)) {
|
||||
updateRecord(scope, rec, name, newValue, cls)
|
||||
@@ -191,24 +221,42 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
|
||||
scope: Scope, name: String, args: Arguments,
|
||||
onNotFoundResult: (suspend () -> Obj?)?
|
||||
): Obj {
|
||||
// 0. Prefer private member of current class context
|
||||
scope.currentClassCtx?.let { caller ->
|
||||
val mangled = "${caller.className}::$name"
|
||||
instanceScope.objects[mangled]?.let { rec ->
|
||||
if (rec.visibility == Visibility.Private && !rec.isAbstract) {
|
||||
if (rec.type == ObjRecord.Type.Property) {
|
||||
if (args.isEmpty()) return (rec.value as ObjProperty).callGetter(scope, this, caller)
|
||||
} else if (rec.type == ObjRecord.Type.Fun) {
|
||||
return rec.value.invoke(instanceScope, this, args, caller)
|
||||
val caller = scope.currentClassCtx
|
||||
|
||||
// Fast path for public members when outside any class context
|
||||
if (caller == null) {
|
||||
objClass.publicMemberResolution[name]?.let { key ->
|
||||
instanceScope.objects[key]?.let { rec ->
|
||||
if (rec.visibility == Visibility.Public && !rec.isAbstract) {
|
||||
val decl = rec.declaringClass
|
||||
if (rec.type == ObjRecord.Type.Property) {
|
||||
if (args.isEmpty()) return (rec.value as ObjProperty).callGetter(scope, this, decl)
|
||||
} else if (rec.type == ObjRecord.Type.Fun) {
|
||||
return rec.value.invoke(instanceScope, this, args, decl)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
caller.members[name]?.let { rec ->
|
||||
}
|
||||
|
||||
// 0. Prefer private member of current class context
|
||||
caller?.let { c ->
|
||||
val mangled = c.mangledName(name)
|
||||
instanceScope.objects[mangled]?.let { rec ->
|
||||
if (rec.visibility == Visibility.Private && !rec.isAbstract) {
|
||||
if (rec.type == ObjRecord.Type.Property) {
|
||||
if (args.isEmpty()) return (rec.value as ObjProperty).callGetter(scope, this, caller)
|
||||
if (args.isEmpty()) return (rec.value as ObjProperty).callGetter(scope, this, c)
|
||||
} else if (rec.type == ObjRecord.Type.Fun) {
|
||||
return rec.value.invoke(instanceScope, this, args, caller)
|
||||
return rec.value.invoke(instanceScope, this, args, c)
|
||||
}
|
||||
}
|
||||
}
|
||||
c.members[name]?.let { rec ->
|
||||
if (rec.visibility == Visibility.Private && !rec.isAbstract) {
|
||||
if (rec.type == ObjRecord.Type.Property) {
|
||||
if (args.isEmpty()) return (rec.value as ObjProperty).callGetter(scope, this, c)
|
||||
} else if (rec.type == ObjRecord.Type.Fun) {
|
||||
return rec.value.invoke(instanceScope, this, args, c)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -220,7 +268,7 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
|
||||
val rec = cls.members[name] ?: cls.classScope?.objects?.get(name)
|
||||
if (rec != null && !rec.isAbstract) {
|
||||
if (rec.type == ObjRecord.Type.Delegated) {
|
||||
val storageName = "${cls.className}::$name"
|
||||
val storageName = cls.mangledName(name)
|
||||
val del = instanceScope[storageName]?.delegate ?: rec.delegate
|
||||
?: scope.raiseError("Internal error: delegated member $name has no delegate (tried $storageName)")
|
||||
|
||||
@@ -233,8 +281,8 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
|
||||
})
|
||||
}
|
||||
val decl = rec.declaringClass ?: cls
|
||||
val caller = scope.currentClassCtx ?: if (scope.thisObj === this) objClass else null
|
||||
if (!canAccessMember(rec.visibility, decl, caller))
|
||||
val effectiveCaller = caller ?: if (scope.thisObj === this) objClass else null
|
||||
if (!canAccessMember(rec.visibility, decl, effectiveCaller))
|
||||
scope.raiseError(
|
||||
ObjIllegalAccessException(
|
||||
scope,
|
||||
|
||||
File diff suppressed because it is too large.
Load diff
@@ -79,6 +79,14 @@ data class ObjString(val value: String) : Obj() {
|
||||
}
|
||||
}
|
||||
|
||||
override suspend fun mul(scope: Scope, other: Obj): Obj {
|
||||
var times = other.toInt()
|
||||
if( times < 0 ) scope.raiseIllegalArgument("negative string repetitions")
|
||||
return ObjString( buildString {
|
||||
while( times-- > 0 ) append(value)
|
||||
})
|
||||
}
|
||||
|
||||
override fun hashCode(): Int {
|
||||
return value.hashCode()
|
||||
}
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
@@ -18,10 +18,7 @@
|
||||
package net.sergeych.lynon
|
||||
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.obj.Obj
|
||||
import net.sergeych.lyng.obj.ObjBitBuffer
|
||||
import net.sergeych.lyng.obj.ObjClass
|
||||
import net.sergeych.lyng.obj.ObjString
|
||||
import net.sergeych.lyng.obj.*
|
||||
|
||||
// Most often used types:
|
||||
|
||||
@@ -53,14 +50,35 @@ object ObjLynonClass : ObjClass("Lynon") {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Encode any object into Lynon format. Note that it has a special
|
||||
* handling for void values, returning an empty byte array.
|
||||
*
|
||||
* This is the default behavior for encoding void values in Lynon format,
|
||||
* ensuring consistency with decoding behavior. It matches the [lynonDecodeAny]
|
||||
* behavior for handling void values.
|
||||
*/
|
||||
@Suppress("unused")
|
||||
suspend fun lynonEncodeAny(scope: Scope, value: Obj): UByteArray =
|
||||
(ObjLynonClass.encodeAny(scope, value))
|
||||
.bitArray.asUByteArray()
|
||||
if (value == ObjVoid)
|
||||
ubyteArrayOf()
|
||||
else
|
||||
(ObjLynonClass.encodeAny(scope, value))
|
||||
.bitArray.asUByteArray()
|
||||
|
||||
|
||||
/**
|
||||
* Decode any object from Lynon format. If the input is empty, returns ObjVoid.
|
||||
* This behavior is designed to handle cases where the input data might be incomplete
|
||||
* or intentionally left empty, indicating a void or null value and matches
|
||||
* the [lynonEncodeAny] behavior [ObjVoid].
|
||||
*/
|
||||
@Suppress("unused")
|
||||
suspend fun lynonDecodeAny(scope: Scope, encoded: UByteArray): Obj =
|
||||
ObjLynonClass.decodeAny(
|
||||
if (encoded.isEmpty())
|
||||
ObjVoid
|
||||
else
|
||||
ObjLynonClass.decodeAny(
|
||||
scope,
|
||||
ObjBitBuffer(
|
||||
BitArray(encoded, 8)
|
||||
|
||||
@@ -168,6 +168,7 @@ class MiniAstTest {
|
||||
assertNotNull(ed.doc)
|
||||
assertTrue(ed.doc.raw.contains("Enum E docs"))
|
||||
assertEquals(listOf("A", "B", "C"), ed.entries)
|
||||
assertEquals(3, ed.entryPositions.size)
|
||||
assertEquals("E", ed.name)
|
||||
}
|
||||
|
||||
@@ -419,6 +420,25 @@ class MiniAstTest {
|
||||
assertEquals("Int", innerArg.segments.last().name)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun verify_class_member_structure() = runTest {
|
||||
val code = """
|
||||
class A {
|
||||
fun member() {}
|
||||
val field = 1
|
||||
}
|
||||
""".trimIndent()
|
||||
val (_, sink) = compileWithMini(code)
|
||||
val mini = sink.build()!!
|
||||
println("[DEBUG_LOG] Mini declarations: ${mini.declarations.map { it.name }}")
|
||||
assertEquals(1, mini.declarations.size, "Should only have one top-level declaration (class A)")
|
||||
val cls = mini.declarations[0] as MiniClassDecl
|
||||
assertEquals("A", cls.name)
|
||||
assertEquals(2, cls.members.size, "Class A should have 2 members (member() and field)")
|
||||
assertTrue(cls.members.any { it.name == "member" && it is MiniMemberFunDecl })
|
||||
assertTrue(cls.members.any { it.name == "field" && it is MiniMemberValDecl })
|
||||
}
|
||||
|
||||
@Test
|
||||
fun inferTypeForValWithInference() = runTest {
|
||||
val code = """
|
||||
@@ -439,4 +459,73 @@ class MiniAstTest {
|
||||
val className = DocLookupUtils.simpleClassNameOf(type)
|
||||
assertEquals("List", className)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun miniAst_captures_fun_with_type_and_default() = runTest {
|
||||
val code = """
|
||||
fun foo(a: Int, b: String = "ok"): Bool { true }
|
||||
""".trimIndent()
|
||||
val (_, sink) = compileWithMini(code)
|
||||
val mini = sink.build()
|
||||
assertNotNull(mini)
|
||||
val fn = mini.declarations.filterIsInstance<MiniFunDecl>().firstOrNull { it.name == "foo" }
|
||||
assertNotNull(fn)
|
||||
assertEquals(2, fn.params.size)
|
||||
assertEquals("a", fn.params[0].name)
|
||||
assertEquals("b", fn.params[1].name)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun miniAst_captures_dokka_tags() = runTest {
|
||||
val code = """
|
||||
/**
|
||||
* Testing tags.
|
||||
* @param x the x value
|
||||
* @param y the y value
|
||||
* @return some string
|
||||
* @throws Exception if failed
|
||||
*/
|
||||
fun tagged(x: Int, y: Int): String { "" }
|
||||
""".trimIndent()
|
||||
val (_, sink) = compileWithMini(code)
|
||||
val mini = sink.build()
|
||||
assertNotNull(mini)
|
||||
val fn = mini.declarations.filterIsInstance<MiniFunDecl>().firstOrNull { it.name == "tagged" }
|
||||
assertNotNull(fn)
|
||||
val doc = fn.doc
|
||||
assertNotNull(doc)
|
||||
assertEquals("Testing tags.", doc.summary)
|
||||
|
||||
val tags = doc.tags
|
||||
assertTrue(tags.containsKey("param"), "should have @param tags")
|
||||
assertEquals(listOf("x the x value", "y the y value"), tags["param"])
|
||||
assertEquals(listOf("some string"), tags["return"])
|
||||
assertEquals(listOf("Exception if failed"), tags["throws"])
|
||||
}
|
||||
|
||||
@Test
|
||||
fun miniAst_captures_multiline_tags() = runTest {
|
||||
val code = """
|
||||
/**
|
||||
* Multi line tag.
|
||||
* @param x first line of x
|
||||
* second line of x
|
||||
* @return return value
|
||||
*/
|
||||
fun multiline(x: Int): Int { 0 }
|
||||
""".trimIndent()
|
||||
val (_, sink) = compileWithMini(code)
|
||||
val mini = sink.build()
|
||||
assertNotNull(mini)
|
||||
val fn = mini.declarations.filterIsInstance<MiniFunDecl>().firstOrNull { it.name == "multiline" }
|
||||
assertNotNull(fn)
|
||||
val doc = fn.doc
|
||||
assertNotNull(doc)
|
||||
|
||||
val tags = doc.tags
|
||||
assertTrue(tags.containsKey("param"), "should have @param tags")
|
||||
val xParam = tags["param"]?.first() ?: ""
|
||||
assertTrue(xParam.contains("first line of x"), "should contain first line")
|
||||
assertTrue(xParam.contains("second line of x"), "should contain second line")
|
||||
}
|
||||
}
|
||||
@@ -4160,6 +4160,14 @@ class ScriptTest {
|
||||
)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testStringMul() = runTest {
|
||||
eval("""
|
||||
assertEquals("hellohello", "hello"*2)
|
||||
assertEquals("", "hello"*0)
|
||||
""".trimIndent())
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testLogicalNot() = runTest {
|
||||
eval(
|
||||
@@ -4672,6 +4680,29 @@ class ScriptTest {
|
||||
// source name, in our case, is is "tc2":
|
||||
assertContains(x1.message!!, "tc2")
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testFilterStackTrace() = runTest {
|
||||
var x = try {
|
||||
evalNamed( "tc1","""
|
||||
fun f2() = throw IllegalArgumentException("test3")
|
||||
fun f1() = f2()
|
||||
f1()
|
||||
""".trimIndent())
|
||||
fail("this should throw")
|
||||
}
|
||||
catch(x: ExecutionError) {
|
||||
x
|
||||
}
|
||||
assertEquals("""
|
||||
tc1:1:12: test3
|
||||
at tc1:1:12: fun f2() = throw IllegalArgumentException("test3")
|
||||
at tc1:2:12: fun f1() = f2()
|
||||
at tc1:3:1: f1()
|
||||
""".trimIndent(),x.errorObject.getLyngExceptionMessageWithStackTrace())
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
fun testLyngToKotlinExceptionHelpers() = runTest {
|
||||
var x = evalNamed( "tc1","""
|
||||
@@ -4796,5 +4827,33 @@ class ScriptTest {
|
||||
assertEquals("r:r", T().l("r"))
|
||||
""".trimIndent())
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testTypedArgsWithInitializers() = runTest {
|
||||
eval("""
|
||||
fun f(a: String = "foo") = a + "!"
|
||||
fun g(a: String? = null) = a ?: "!!"
|
||||
assertEquals(f(), "foo!")
|
||||
assertEquals(g(), "!!")
|
||||
assertEquals(f("bar"), "bar!")
|
||||
class T(b: Int=42,c: String?=null)
|
||||
assertEquals(42, T().b)
|
||||
assertEquals(null, T().c)
|
||||
""".trimIndent())
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testArgsPriorityWithSplash() = runTest {
|
||||
eval("""
|
||||
class A {
|
||||
val tags get() = ["foo"]
|
||||
|
||||
fun f1(tags...) = tags
|
||||
|
||||
fun f2(tags...) = f1(...tags)
|
||||
}
|
||||
assertEquals(["bar"], A().f2("bar"))
|
||||
""")
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,55 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyng.miniast
|
||||
|
||||
import kotlinx.coroutines.test.runTest
|
||||
import net.sergeych.lyng.Compiler
|
||||
import net.sergeych.lyng.binding.Binder
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
|
||||
class ParamTypeInferenceTest {
|
||||
|
||||
@Test
|
||||
fun testParameterTypeInference() = runTest {
|
||||
val code = """
|
||||
class A {
|
||||
fun foo(p: String) {
|
||||
p.
|
||||
}
|
||||
}
|
||||
|
||||
fun bar(q: Int) {
|
||||
q.
|
||||
}
|
||||
""".trimIndent()
|
||||
|
||||
val sink = MiniAstBuilder()
|
||||
Compiler.compileWithMini(code.trimIndent(), sink)
|
||||
val mini = sink.build()!!
|
||||
val binding = Binder.bind(code, mini)
|
||||
|
||||
val dotPosQ = code.indexOf("q.") + 1
|
||||
val receiverClassQ = DocLookupUtils.guessReceiverClassViaMini(mini, code, dotPosQ, listOf("lyng.stdlib"), binding)
|
||||
assertEquals("Int", receiverClassQ, "Should infer type of parameter q in top-level function")
|
||||
|
||||
val dotPosP = code.indexOf("p.") + 1
|
||||
val receiverClassP = DocLookupUtils.guessReceiverClassViaMini(mini, code, dotPosP, listOf("lyng.stdlib"), binding)
|
||||
assertEquals("String", receiverClassP, "Should infer type of parameter p in member function")
|
||||
}
|
||||
}
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
@@ -23,7 +23,7 @@ actual object PerfDefaults {
|
||||
|
||||
actual val ARG_BUILDER: Boolean = true
|
||||
actual val SKIP_ARGS_ON_NULL_RECEIVER: Boolean = true
|
||||
actual val SCOPE_POOL: Boolean = false
|
||||
actual val SCOPE_POOL: Boolean = true
|
||||
|
||||
actual val FIELD_PIC: Boolean = true
|
||||
actual val METHOD_PIC: Boolean = true
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
@@ -18,7 +18,6 @@
|
||||
package net.sergeych.lyng
|
||||
|
||||
import net.sergeych.lyng.obj.Obj
|
||||
import net.sergeych.lyng.obj.ObjVoid
|
||||
|
||||
/**
|
||||
* JS actual: simple global deque pool (single-threaded runtime).
|
||||
@@ -28,23 +27,30 @@ actual object ScopePool {
|
||||
private val pool = ArrayDeque<Scope>(MAX_POOL_SIZE)
|
||||
|
||||
actual fun borrow(parent: Scope, args: Arguments, pos: Pos, thisObj: Obj): Scope {
|
||||
val s = if (pool.isNotEmpty()) pool.removeLast() else Scope(parent, args, pos, thisObj)
|
||||
return try {
|
||||
if (s.parent !== parent || s.args !== args || s.pos !== pos || s.thisObj !== thisObj) {
|
||||
if (pool.isNotEmpty()) {
|
||||
val s = pool.removeLast()
|
||||
try {
|
||||
// Re-initialize pooled instance
|
||||
s.resetForReuse(parent, args, pos, thisObj)
|
||||
} else {
|
||||
s.frameId = nextFrameId()
|
||||
return s
|
||||
} catch (e: IllegalStateException) {
|
||||
// Defensive fallback: if a cycle in scope parent chain is detected during reuse,
|
||||
// discard pooled instance for this call frame and allocate a fresh scope instead.
|
||||
if (e.message?.contains("cycle") == true && e.message?.contains("scope parent chain") == true) {
|
||||
return Scope(parent, args, pos, thisObj)
|
||||
} else {
|
||||
throw e
|
||||
}
|
||||
}
|
||||
s
|
||||
} catch (e: IllegalStateException) {
|
||||
if (e.message?.contains("cycle") == true && e.message?.contains("scope parent chain") == true) {
|
||||
Scope(parent, args, pos, thisObj)
|
||||
} else throw e
|
||||
}
|
||||
return Scope(parent, args, pos, thisObj)
|
||||
}
|
||||
|
||||
actual fun release(scope: Scope) {
|
||||
scope.resetForReuse(parent = null, args = Arguments.EMPTY, pos = Pos.builtIn, thisObj = ObjVoid)
|
||||
if (pool.size < MAX_POOL_SIZE) pool.addLast(scope)
|
||||
if (pool.size < MAX_POOL_SIZE) {
|
||||
// Scrub sensitive references to avoid accidental retention before returning to pool
|
||||
scope.scrub()
|
||||
pool.addLast(scope)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
@@ -18,35 +18,35 @@
|
||||
package net.sergeych.lyng
|
||||
|
||||
actual object PerfDefaults {
|
||||
actual val LOCAL_SLOT_PIC: Boolean = false
|
||||
actual val EMIT_FAST_LOCAL_REFS: Boolean = false
|
||||
actual val LOCAL_SLOT_PIC: Boolean = true
|
||||
actual val EMIT_FAST_LOCAL_REFS: Boolean = true
|
||||
|
||||
actual val ARG_BUILDER: Boolean = false
|
||||
actual val SKIP_ARGS_ON_NULL_RECEIVER: Boolean = false
|
||||
actual val SCOPE_POOL: Boolean = false
|
||||
actual val ARG_BUILDER: Boolean = true
|
||||
actual val SKIP_ARGS_ON_NULL_RECEIVER: Boolean = true
|
||||
actual val SCOPE_POOL: Boolean = true
|
||||
|
||||
actual val FIELD_PIC: Boolean = false
|
||||
actual val METHOD_PIC: Boolean = false
|
||||
actual val FIELD_PIC_SIZE_4: Boolean = false
|
||||
actual val METHOD_PIC_SIZE_4: Boolean = false
|
||||
actual val PIC_ADAPTIVE_2_TO_4: Boolean = false
|
||||
actual val PIC_ADAPTIVE_METHODS_ONLY: Boolean = false
|
||||
actual val PIC_ADAPTIVE_HEURISTIC: Boolean = false
|
||||
actual val FIELD_PIC: Boolean = true
|
||||
actual val METHOD_PIC: Boolean = true
|
||||
actual val FIELD_PIC_SIZE_4: Boolean = true
|
||||
actual val METHOD_PIC_SIZE_4: Boolean = true
|
||||
actual val PIC_ADAPTIVE_2_TO_4: Boolean = true
|
||||
actual val PIC_ADAPTIVE_METHODS_ONLY: Boolean = true
|
||||
actual val PIC_ADAPTIVE_HEURISTIC: Boolean = true
|
||||
|
||||
actual val PIC_DEBUG_COUNTERS: Boolean = false
|
||||
|
||||
actual val PRIMITIVE_FASTOPS: Boolean = false
|
||||
actual val RVAL_FASTPATH: Boolean = false
|
||||
actual val PRIMITIVE_FASTOPS: Boolean = true
|
||||
actual val RVAL_FASTPATH: Boolean = true
|
||||
|
||||
// Regex caching (JVM-first): enabled by default on JVM
|
||||
actual val REGEX_CACHE: Boolean = true
|
||||
|
||||
// Extended small-arity calls 9..12 (experimental; keep OFF by default)
|
||||
actual val ARG_SMALL_ARITY_12: Boolean = false
|
||||
actual val ARG_SMALL_ARITY_12: Boolean = true
|
||||
|
||||
// Index PIC size (beneficial on JVM in A/B): enable size=4 by default
|
||||
actual val INDEX_PIC_SIZE_4: Boolean = true
|
||||
|
||||
// Range fast-iteration (experimental; OFF by default)
|
||||
actual val RANGE_FAST_ITER: Boolean = false
|
||||
actual val RANGE_FAST_ITER: Boolean = true
|
||||
}
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
@@ -18,7 +18,6 @@
|
||||
package net.sergeych.lyng
|
||||
|
||||
import net.sergeych.lyng.obj.Obj
|
||||
import net.sergeych.lyng.obj.ObjVoid
|
||||
|
||||
/**
|
||||
* JVM actual: per-thread scope frame pool backed by ThreadLocal.
|
||||
@@ -32,26 +31,31 @@ actual object ScopePool {
|
||||
|
||||
actual fun borrow(parent: Scope, args: Arguments, pos: Pos, thisObj: Obj): Scope {
|
||||
val pool = threadLocalPool.get()
|
||||
val s = if (pool.isNotEmpty()) pool.removeLast() else Scope(parent, args, pos, thisObj)
|
||||
return try {
|
||||
// Always reset state on borrow to guarantee fresh-frame semantics
|
||||
s.resetForReuse(parent, args, pos, thisObj)
|
||||
s
|
||||
} catch (e: IllegalStateException) {
|
||||
// Defensive fallback: if a cycle in scope parent chain is detected during reuse,
|
||||
// discard pooled instance for this call frame and allocate a fresh scope instead.
|
||||
if (e.message?.contains("cycle") == true && e.message?.contains("scope parent chain") == true) {
|
||||
Scope(parent, args, pos, thisObj)
|
||||
} else {
|
||||
throw e
|
||||
if (pool.isNotEmpty()) {
|
||||
val s = pool.removeLast()
|
||||
try {
|
||||
// Re-initialize pooled instance
|
||||
s.resetForReuse(parent, args, pos, thisObj)
|
||||
return s
|
||||
} catch (e: IllegalStateException) {
|
||||
// Defensive fallback: if a cycle in scope parent chain is detected during reuse,
|
||||
// discard pooled instance for this call frame and allocate a fresh scope instead.
|
||||
if (e.message?.contains("cycle") == true && e.message?.contains("scope parent chain") == true) {
|
||||
return Scope(parent, args, pos, thisObj)
|
||||
} else {
|
||||
throw e
|
||||
}
|
||||
}
|
||||
}
|
||||
return Scope(parent, args, pos, thisObj)
|
||||
}
|
||||
|
||||
actual fun release(scope: Scope) {
|
||||
val pool = threadLocalPool.get()
|
||||
// Scrub sensitive references to avoid accidental retention
|
||||
scope.resetForReuse(parent = null, args = Arguments.EMPTY, pos = Pos.builtIn, thisObj = ObjVoid)
|
||||
if (pool.size < MAX_POOL_SIZE) pool.addLast(scope)
|
||||
if (pool.size < MAX_POOL_SIZE) {
|
||||
// Scrub sensitive references to avoid accidental retention before returning to pool
|
||||
scope.scrub()
|
||||
pool.addLast(scope)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
@@ -88,20 +88,57 @@ class PicBenchmarkTest {
|
||||
|
||||
// PIC OFF
|
||||
PerfFlags.METHOD_PIC = false
|
||||
PerfFlags.SCOPE_POOL = false
|
||||
val scope1 = Scope()
|
||||
val t0 = System.nanoTime()
|
||||
val r1 = (scope1.eval(script) as ObjInt).value
|
||||
val t1 = System.nanoTime()
|
||||
println("[DEBUG_LOG] [BENCH] Method PIC=OFF: ${(t1 - t0) / 1_000_000.0} ms")
|
||||
println("[DEBUG_LOG] [BENCH] Method PIC=OFF, POOL=OFF: ${(t1 - t0) / 1_000_000.0} ms")
|
||||
assertEquals(iterations.toLong(), r1)
|
||||
|
||||
// PIC ON
|
||||
PerfFlags.METHOD_PIC = true
|
||||
PerfFlags.SCOPE_POOL = true
|
||||
val scope2 = Scope()
|
||||
val t2 = System.nanoTime()
|
||||
val r2 = (scope2.eval(script) as ObjInt).value
|
||||
val t3 = System.nanoTime()
|
||||
println("[DEBUG_LOG] [BENCH] Method PIC=ON: ${(t3 - t2) / 1_000_000.0} ms")
|
||||
println("[DEBUG_LOG] [BENCH] Method PIC=ON, POOL=ON: ${(t3 - t2) / 1_000_000.0} ms")
|
||||
assertEquals(iterations.toLong(), r2)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun benchmarkLoopScopePooling() = runBlocking {
|
||||
val iterations = 500_000
|
||||
val script = """
|
||||
var x = 0
|
||||
var i = 0
|
||||
while(i < $iterations) {
|
||||
if(true) {
|
||||
var y = 1
|
||||
x = x + y
|
||||
}
|
||||
i = i + 1
|
||||
}
|
||||
x
|
||||
""".trimIndent()
|
||||
|
||||
// POOL OFF
|
||||
PerfFlags.SCOPE_POOL = false
|
||||
val scope1 = Scope()
|
||||
val t0 = System.nanoTime()
|
||||
val r1 = (scope1.eval(script) as ObjInt).value
|
||||
val t1 = System.nanoTime()
|
||||
println("[DEBUG_LOG] [BENCH] Loop Pool=OFF: ${(t1 - t0) / 1_000_000.0} ms")
|
||||
assertEquals(iterations.toLong(), r1)
|
||||
|
||||
// POOL ON
|
||||
PerfFlags.SCOPE_POOL = true
|
||||
val scope2 = Scope()
|
||||
val t2 = System.nanoTime()
|
||||
val r2 = (scope2.eval(script) as ObjInt).value
|
||||
val t3 = System.nanoTime()
|
||||
println("[DEBUG_LOG] [BENCH] Loop Pool=ON: ${(t3 - t2) / 1_000_000.0} ms")
|
||||
assertEquals(iterations.toLong(), r2)
|
||||
}
|
||||
}
|
||||
@@ -1,3 +1,20 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyng.miniast
|
||||
|
||||
import kotlinx.coroutines.runBlocking
|
||||
@@ -462,6 +479,34 @@ class CompletionEngineLightTest {
|
||||
assertTrue(ns.contains("size"), "String member 'size' should be suggested for local x[0] inside set(), but got: $ns")
|
||||
}
|
||||
|
||||
@Test
|
||||
fun functionArgumentsInBody() = runBlocking {
|
||||
val code = """
|
||||
fun test(myArg1, myArg2) {
|
||||
myA<caret>
|
||||
}
|
||||
""".trimIndent()
|
||||
val items = CompletionEngineLight.completeAtMarkerSuspend(code)
|
||||
val ns = names(items)
|
||||
assertTrue(ns.contains("myArg1"), "Function argument 'myArg1' should be proposed, but got: $ns")
|
||||
assertTrue(ns.contains("myArg2"), "Function argument 'myArg2' should be proposed, but got: $ns")
|
||||
}
|
||||
|
||||
@Test
|
||||
fun methodArgumentsInBody() = runBlocking {
|
||||
val code = """
|
||||
class MyClass {
|
||||
fun test(myArg1, myArg2) {
|
||||
myA<caret>
|
||||
}
|
||||
}
|
||||
""".trimIndent()
|
||||
val items = CompletionEngineLight.completeAtMarkerSuspend(code)
|
||||
val ns = names(items)
|
||||
assertTrue(ns.contains("myArg1"), "Method argument 'myArg1' should be proposed, but got: $ns")
|
||||
assertTrue(ns.contains("myArg2"), "Method argument 'myArg2' should be proposed, but got: $ns")
|
||||
}
|
||||
|
||||
@Test
|
||||
fun nestedShadowingCompletion() = runBlocking {
|
||||
val code = """
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
@@ -23,7 +23,7 @@ actual object PerfDefaults {
|
||||
|
||||
actual val ARG_BUILDER: Boolean = true
|
||||
actual val SKIP_ARGS_ON_NULL_RECEIVER: Boolean = true
|
||||
actual val SCOPE_POOL: Boolean = false
|
||||
actual val SCOPE_POOL: Boolean = true
|
||||
|
||||
actual val FIELD_PIC: Boolean = true
|
||||
actual val METHOD_PIC: Boolean = true
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
@@ -18,33 +18,40 @@
|
||||
package net.sergeych.lyng
|
||||
|
||||
import net.sergeych.lyng.obj.Obj
|
||||
import net.sergeych.lyng.obj.ObjVoid
|
||||
|
||||
/**
|
||||
* Native actual: simple global deque pool. Many native targets are single-threaded by default in our setup.
|
||||
* Native actual: per-thread scope frame pool using @ThreadLocal.
|
||||
*/
|
||||
@kotlin.native.concurrent.ThreadLocal
|
||||
actual object ScopePool {
|
||||
private const val MAX_POOL_SIZE = 64
|
||||
private val pool = ArrayDeque<Scope>(MAX_POOL_SIZE)
|
||||
|
||||
actual fun borrow(parent: Scope, args: Arguments, pos: Pos, thisObj: Obj): Scope {
|
||||
val s = if (pool.isNotEmpty()) pool.removeLast() else Scope(parent, args, pos, thisObj)
|
||||
return try {
|
||||
if (s.parent !== parent || s.args !== args || s.pos !== pos || s.thisObj !== thisObj) {
|
||||
if (pool.isNotEmpty()) {
|
||||
val s = pool.removeLast()
|
||||
try {
|
||||
// Re-initialize pooled instance
|
||||
s.resetForReuse(parent, args, pos, thisObj)
|
||||
} else {
|
||||
s.frameId = nextFrameId()
|
||||
return s
|
||||
} catch (e: IllegalStateException) {
|
||||
// Defensive fallback: if a cycle in scope parent chain is detected during reuse,
|
||||
// discard pooled instance for this call frame and allocate a fresh scope instead.
|
||||
if (e.message?.contains("cycle") == true && e.message?.contains("scope parent chain") == true) {
|
||||
return Scope(parent, args, pos, thisObj)
|
||||
} else {
|
||||
throw e
|
||||
}
|
||||
}
|
||||
s
|
||||
} catch (e: IllegalStateException) {
|
||||
if (e.message?.contains("cycle") == true && e.message?.contains("scope parent chain") == true) {
|
||||
Scope(parent, args, pos, thisObj)
|
||||
} else throw e
|
||||
}
|
||||
return Scope(parent, args, pos, thisObj)
|
||||
}
|
||||
|
||||
actual fun release(scope: Scope) {
|
||||
scope.resetForReuse(parent = null, args = Arguments.EMPTY, pos = Pos.builtIn, thisObj = ObjVoid)
|
||||
if (pool.size < MAX_POOL_SIZE) pool.addLast(scope)
|
||||
if (pool.size < MAX_POOL_SIZE) {
|
||||
// Scrub sensitive references to avoid accidental retention before returning to pool
|
||||
scope.scrub()
|
||||
pool.addLast(scope)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
@@ -23,7 +23,7 @@ actual object PerfDefaults {
|
||||
|
||||
actual val ARG_BUILDER: Boolean = true
|
||||
actual val SKIP_ARGS_ON_NULL_RECEIVER: Boolean = true
|
||||
actual val SCOPE_POOL: Boolean = false
|
||||
actual val SCOPE_POOL: Boolean = true
|
||||
|
||||
actual val FIELD_PIC: Boolean = true
|
||||
actual val METHOD_PIC: Boolean = true
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
@@ -18,7 +18,6 @@
|
||||
package net.sergeych.lyng
|
||||
|
||||
import net.sergeych.lyng.obj.Obj
|
||||
import net.sergeych.lyng.obj.ObjVoid
|
||||
|
||||
/**
|
||||
* Wasm/JS actual: simple global deque pool (single-threaded runtime model).
|
||||
@@ -28,23 +27,30 @@ actual object ScopePool {
|
||||
private val pool = ArrayDeque<Scope>(MAX_POOL_SIZE)
|
||||
|
||||
actual fun borrow(parent: Scope, args: Arguments, pos: Pos, thisObj: Obj): Scope {
|
||||
val s = if (pool.isNotEmpty()) pool.removeLast() else Scope(parent, args, pos, thisObj)
|
||||
return try {
|
||||
if (s.parent !== parent || s.args !== args || s.pos !== pos || s.thisObj !== thisObj) {
|
||||
if (pool.isNotEmpty()) {
|
||||
val s = pool.removeLast()
|
||||
try {
|
||||
// Re-initialize pooled instance
|
||||
s.resetForReuse(parent, args, pos, thisObj)
|
||||
} else {
|
||||
s.frameId = nextFrameId()
|
||||
return s
|
||||
} catch (e: IllegalStateException) {
|
||||
// Defensive fallback: if a cycle in scope parent chain is detected during reuse,
|
||||
// discard pooled instance for this call frame and allocate a fresh scope instead.
|
||||
if (e.message?.contains("cycle") == true && e.message?.contains("scope parent chain") == true) {
|
||||
return Scope(parent, args, pos, thisObj)
|
||||
} else {
|
||||
throw e
|
||||
}
|
||||
}
|
||||
s
|
||||
} catch (e: IllegalStateException) {
|
||||
if (e.message?.contains("cycle") == true && e.message?.contains("scope parent chain") == true) {
|
||||
Scope(parent, args, pos, thisObj)
|
||||
} else throw e
|
||||
}
|
||||
return Scope(parent, args, pos, thisObj)
|
||||
}
|
||||
|
||||
actual fun release(scope: Scope) {
|
||||
scope.resetForReuse(parent = null, args = Arguments.EMPTY, pos = Pos.builtIn, thisObj = ObjVoid)
|
||||
if (pool.size < MAX_POOL_SIZE) pool.addLast(scope)
|
||||
if (pool.size < MAX_POOL_SIZE) {
|
||||
// Scrub sensitive references to avoid accidental retention before returning to pool
|
||||
scope.scrub()
|
||||
pool.addLast(scope)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -39,7 +39,7 @@ fun Iterable.filter(predicate) {
|
||||
}
|
||||
|
||||
/*
|
||||
Count all items in this iterable for which predicate return true
|
||||
Count all items in this iterable for which predicate returns true
|
||||
*/
|
||||
fun Iterable.count(predicate): Int {
|
||||
var hits = 0
|
||||
@@ -266,12 +266,8 @@ class StackTraceEntry(
|
||||
/* Print this exception and its stack trace to standard output. */
|
||||
fun Exception.printStackTrace() {
|
||||
println(this)
|
||||
var lastEntry = null
|
||||
for( entry in stackTrace ) {
|
||||
if( lastEntry == null || lastEntry !is StackTraceEntry || lastEntry.line != entry.line )
|
||||
println("\tat "+entry.toString())
|
||||
lastEntry = entry
|
||||
}
|
||||
for( entry in stackTrace )
|
||||
println("\tat "+entry.toString())
|
||||
}
|
||||
|
||||
/* Compile this string into a regular expression. */
|
||||
|
||||
@@ -98,6 +98,7 @@ fun applyEnter(text: String, selStart: Int, selEnd: Int, tabSize: Int): EditResu
|
||||
val lineStart = lineStartAt(text, start)
|
||||
val lineEnd = lineEndAt(text, start)
|
||||
val indent = countIndentSpaces(text, lineStart, lineEnd)
|
||||
val lineTrimmed = text.substring(lineStart, lineEnd).trim()
|
||||
|
||||
// Compute neighborhood characters early so rule precedence can use them
|
||||
val prevIdx = prevNonWs(text, start)
|
||||
@@ -107,7 +108,7 @@ fun applyEnter(text: String, selStart: Int, selEnd: Int, tabSize: Int): EditResu
|
||||
val before = text.substring(0, start)
|
||||
val after = text.substring(start)
|
||||
|
||||
// 1) Between braces { | } -> two lines, inner indented
|
||||
// Rule 4: Between braces on the same line {|}
|
||||
if (prevCh == '{' && nextCh == '}') {
|
||||
val innerIndent = indent + tabSize
|
||||
val insertion = "\n" + " ".repeat(innerIndent) + "\n" + " ".repeat(indent)
|
||||
@@ -115,22 +116,51 @@ fun applyEnter(text: String, selStart: Int, selEnd: Int, tabSize: Int): EditResu
|
||||
val caret = start + 1 + innerIndent
|
||||
return EditResult(out, caret, caret)
|
||||
}
|
||||
// 2) After '{'
|
||||
|
||||
// Rule 2: On a brace-only line '}'
|
||||
if (lineTrimmed == "}") {
|
||||
val newIndent = (indent - tabSize).coerceAtLeast(0)
|
||||
val newCurrentLine = " ".repeat(newIndent) + "}"
|
||||
val insertion = "\n" + " ".repeat(newIndent)
|
||||
val out = safeSubstring(text, 0, lineStart) + newCurrentLine + insertion + safeSubstring(text, lineEnd, text.length)
|
||||
val caret = lineStart + newCurrentLine.length + insertion.length
|
||||
return EditResult(out, caret, caret)
|
||||
}
|
||||
|
||||
// Rule 1: After '{'
|
||||
if (prevCh == '{') {
|
||||
val insertion = "\n" + " ".repeat(indent + tabSize)
|
||||
val out = before + insertion + after
|
||||
val caret = start + insertion.length
|
||||
return EditResult(out, caret, caret)
|
||||
}
|
||||
// 3) Before '}'
|
||||
if (nextCh == '}') {
|
||||
val insertion = "\n" + " ".repeat(indent)
|
||||
|
||||
// Rule 3: End of a line before a brace-only next line
|
||||
if (start == lineEnd && lineEnd < text.length) {
|
||||
val nextLineStart = lineEnd + 1
|
||||
val nextLineEnd = lineEndAt(text, nextLineStart)
|
||||
val nextLineTrimmed = text.substring(nextLineStart, nextLineEnd).trim()
|
||||
if (nextLineTrimmed == "}") {
|
||||
val nextLineIndent = countIndentSpaces(text, nextLineStart, nextLineEnd)
|
||||
val newNextLineIndent = (nextLineIndent - tabSize).coerceAtLeast(0)
|
||||
val newNextLine = " ".repeat(newNextLineIndent) + "}"
|
||||
val out = text.substring(0, nextLineStart) + newNextLine + text.substring(nextLineEnd)
|
||||
val caret = nextLineStart + newNextLineIndent
|
||||
return EditResult(out, caret, caret)
|
||||
}
|
||||
}
|
||||
|
||||
// Rule 5: After '}' with only spaces until end-of-line
|
||||
val afterCaretOnLine = text.substring(start, lineEnd)
|
||||
if (prevCh == '}' && afterCaretOnLine.trim().isEmpty()) {
|
||||
val newIndent = (indent - tabSize).coerceAtLeast(0)
|
||||
val insertion = "\n" + " ".repeat(newIndent)
|
||||
val out = before + insertion + after
|
||||
val caret = start + insertion.length
|
||||
return EditResult(out, caret, caret)
|
||||
}
|
||||
|
||||
// default keep same indent
|
||||
// Rule 6: Default smart indent
|
||||
val insertion = "\n" + " ".repeat(indent)
|
||||
val out = before + insertion + after
|
||||
val caret = start + insertion.length
|
||||
|
||||
@@ -170,16 +170,9 @@ fun ReferencePage() {
|
||||
}
|
||||
|
||||
// --- helpers (mirror IDE provider minimal renderers) ---
|
||||
private fun typeOf(t: MiniTypeRef?): String = when (t) {
|
||||
is MiniTypeName -> ": " + t.segments.joinToString(".") { it.name } + if (t.nullable) "?" else ""
|
||||
is MiniGenericType -> {
|
||||
val base = typeOf(t.base).removePrefix(": ")
|
||||
val args = t.args.joinToString(", ") { typeOf(it).removePrefix(": ") }
|
||||
": ${base}<${args}>" + if (t.nullable) "?" else ""
|
||||
}
|
||||
is MiniFunctionType -> ": (..) -> .." + if (t.nullable) "?" else ""
|
||||
is MiniTypeVar -> ": ${t.name}" + if (t.nullable) "?" else ""
|
||||
null -> ""
|
||||
private fun typeOf(t: MiniTypeRef?): String {
|
||||
val s = DocLookupUtils.typeOf(t)
|
||||
return if (s.isEmpty()) "" else ": $s"
|
||||
}
|
||||
|
||||
private fun signatureOf(fn: MiniFunDecl): String {
|
||||
|
||||
@@ -329,7 +329,7 @@
|
||||
<!-- Top-left version ribbon -->
|
||||
<div class="corner-ribbon bg-danger text-white">
|
||||
<span style="margin-left: -5em">
|
||||
v1.1.1-SNAPSHOT
|
||||
v1.2.0!
|
||||
</span>
|
||||
</div>
|
||||
<!-- Fixed top navbar for the whole site -->
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
@@ -41,17 +41,23 @@ class EditorE2ETest {
|
||||
// Programmatically type text into the textarea at current selection and dispatch an input event
|
||||
private fun typeText(ta: HTMLTextAreaElement, s: String) {
|
||||
for (ch in s) {
|
||||
val start = ta.selectionStart ?: 0
|
||||
val end = ta.selectionEnd ?: start
|
||||
val before = ta.value.substring(0, start)
|
||||
val after = ta.value.substring(end)
|
||||
ta.value = before + ch + after
|
||||
val newPos = start + 1
|
||||
ta.selectionStart = newPos
|
||||
ta.selectionEnd = newPos
|
||||
// Fire input so EditorWithOverlay updates its state
|
||||
val ev = js("new Event('input', {bubbles:true})")
|
||||
ta.dispatchEvent(ev.unsafeCast<org.w3c.dom.events.Event>())
|
||||
val key = ch.toString()
|
||||
val ev = js("new KeyboardEvent('keydown', {key: key, bubbles: true, cancelable: true})")
|
||||
val wasPrevented = !ta.dispatchEvent(ev.unsafeCast<org.w3c.dom.events.Event>())
|
||||
|
||||
if (!wasPrevented) {
|
||||
val start = ta.selectionStart ?: 0
|
||||
val end = ta.selectionEnd ?: start
|
||||
val before = ta.value.substring(0, start)
|
||||
val after = ta.value.substring(end)
|
||||
ta.value = before + ch + after
|
||||
val newPos = start + 1
|
||||
ta.selectionStart = newPos
|
||||
ta.selectionEnd = newPos
|
||||
// Fire input so EditorWithOverlay updates its state
|
||||
val inputEv = js("new Event('input', {bubbles:true})")
|
||||
ta.dispatchEvent(inputEv.unsafeCast<org.w3c.dom.events.Event>())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -243,10 +249,10 @@ class EditorE2ETest {
|
||||
typeText(ta, "4"); nextFrame()
|
||||
dispatchKey(ta, key = "Enter"); nextFrame(); nextFrame()
|
||||
|
||||
typeText(ta, "}"); nextFrame()
|
||||
typeText(ta, "}"); nextFrame(); nextFrame(); nextFrame()
|
||||
dispatchKey(ta, key = "Enter"); nextFrame(); nextFrame()
|
||||
|
||||
typeText(ta, "5"); nextFrame(); nextFrame()
|
||||
typeText(ta, "5"); nextFrame(); nextFrame(); nextFrame()
|
||||
|
||||
val expected = (
|
||||
"""
|
||||
|
||||
Reference in new issue
Block a user