Compare commits
32
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
e196bc3012 | ||
|
|
7b1ba71ef0 | ||
|
|
8b94432f66 | ||
|
|
338dc00573 | ||
|
|
d0230c5b89 | ||
|
|
5dc2159024 | ||
|
|
0759346e4b | ||
|
|
f848d79d39 | ||
|
|
52a3a96e3f | ||
|
|
b7dfda2f5d | ||
|
|
05e15e8e42 | ||
|
|
d4bb186f85 | ||
|
|
7bc17037f9 | ||
|
|
75723adbbc | ||
|
|
b7fe04d65f | ||
|
|
ec28b219f3 | ||
|
|
6fa57c8197 | ||
|
|
2d2a74656c | ||
|
|
80933c287d | ||
|
|
017111827d | ||
|
|
d2632cb99e | ||
|
|
474293cfe3 | ||
|
|
9924d02cb4 | ||
|
|
1efa96a990 | ||
|
|
f6deabaa38 | ||
|
|
8f04b25fcb | ||
|
|
6b957ae6a3 | ||
|
|
827df9c8cd | ||
|
|
7ab439d949 | ||
|
|
91e6ae29ce | ||
|
|
b9831a422a | ||
|
|
10b7cb2db2 |
No files matched your search
@@ -26,3 +26,4 @@ debug.log
|
||||
/check_output.txt
|
||||
/compile_jvm_output.txt
|
||||
/compile_metadata_output.txt
|
||||
test_output*.txt
|
||||
@@ -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.
|
||||
+12
-1
@@ -2,6 +2,11 @@
|
||||
|
||||
### Unreleased
|
||||
|
||||
- Language: Refined `protected` visibility rules
|
||||
- Ancestor classes can now access `protected` members of their descendants, provided the ancestor also defines or inherits a member with the same name (indicating an override of a member known to the ancestor).
|
||||
- This allows patterns where a base class calls a `protected` method that is implemented in a subclass.
|
||||
- Fixed a regression where self-calls to unmangled members sometimes bypassed visibility checks incorrectly; these are now handled by the refined logic.
|
||||
|
||||
- Language: Added `return` statement
|
||||
- `return [expression]` exits the innermost enclosing callable (function or lambda).
|
||||
- Supports non-local returns using `@label` syntax (e.g., `return@outer 42`).
|
||||
@@ -21,6 +26,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.
|
||||
@@ -90,7 +101,7 @@
|
||||
- Header-specified constructor arguments are passed to direct bases.
|
||||
- Visibility enforcement under MI:
|
||||
- `private` visible only inside the declaring class body.
|
||||
- `protected` visible inside the declaring class and any of its transitive subclasses; unrelated contexts cannot access it (qualification/casts do not bypass).
|
||||
- `protected` visible inside the declaring class and its transitive subclasses. Additionally, ancestor classes can access protected members of their descendants if it's an override of a member known to the ancestor. Unrelated contexts cannot access it (qualification/casts do not bypass).
|
||||
- Diagnostics improvements:
|
||||
- Missing member/field messages include receiver class and linearization order; hints for `this@Type` or casts when helpful.
|
||||
- Invalid `this@Type` reports that the qualifier is not an ancestor and shows the receiver lineage.
|
||||
|
||||
+106
@@ -0,0 +1,106 @@
|
||||
# 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).
|
||||
- **Serialization**: Use `@Transient` attribute before `val`/`var` or constructor parameters to exclude them from Lynon/JSON serialization. Transient fields are also ignored during `==` structural equality checks.
|
||||
- **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 and ancestors for overrides), `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
|
||||
|
||||
|
||||
+2
-2
@@ -23,11 +23,11 @@ There are a lo of ways to construct a buffer:
|
||||
assertEquals( 5, Buffer("hello").size )
|
||||
|
||||
// from bytes, e.g. integers in range 0..255
|
||||
assertEquals( 255, Buffer(1,2,3,255).last() )
|
||||
assertEquals( 255, Buffer(1,2,3,255).last )
|
||||
|
||||
// from whatever iterable that produces bytes, e.g.
|
||||
// integers in 0..255 range:
|
||||
assertEquals( 129, Buffer([1,2,129]).last() )
|
||||
assertEquals( 129, Buffer([1,2,129]).last )
|
||||
|
||||
// Empty buffer of fixed size:
|
||||
assertEquals(100, Buffer(100).size)
|
||||
|
||||
+43
-24
@@ -119,8 +119,9 @@ Properties allow you to define member accessors that look like fields but execut
|
||||
|
||||
### Basic Syntax
|
||||
|
||||
Properties are declared using `val` (read-only) or `var` (read-write) followed by a name and `get()`/`set()` blocks:
|
||||
Properties are declared using `val` (read-only) or `var` (read-write) followed by a name and a `get` (and optionally `set`) accessor. Unlike fields, properties do not have automatic storage and must compute their values or delegate to other members.
|
||||
|
||||
The standard syntax uses parentheses:
|
||||
```lyng
|
||||
class Person(private var _age: Int) {
|
||||
// Read-only property
|
||||
@@ -136,21 +137,17 @@ class Person(private var _age: Int) {
|
||||
if (value >= 0) _age = value
|
||||
}
|
||||
}
|
||||
|
||||
val p = Person(15)
|
||||
assertEquals("Minor", p.ageCategory)
|
||||
p.age = 20
|
||||
assertEquals("Adult", p.ageCategory)
|
||||
```
|
||||
|
||||
### Laconic Expression Shorthand
|
||||
### Laconic Syntax (Optional Parentheses)
|
||||
|
||||
For simple accessors and methods, you can use the `=` shorthand for a more elegant and laconic form:
|
||||
For even cleaner code, you can omit the parentheses for `get` and `set`. This is especially useful for simple expression shorthand:
|
||||
|
||||
```lyng
|
||||
class Circle(val radius: Real) {
|
||||
val area get() = π * radius * radius
|
||||
val circumference get() = 2 * π * radius
|
||||
// Laconic expression shorthand
|
||||
val area get = π * radius * radius
|
||||
val circumference get = 2 * π * radius
|
||||
|
||||
fun diameter() = radius * 2
|
||||
}
|
||||
@@ -159,15 +156,16 @@ fun median(a, b) = (a + b) / 2
|
||||
|
||||
class Counter {
|
||||
private var _count = 0
|
||||
var count get() = _count set(v) = _count = v
|
||||
var count get = _count set(v) = _count = v
|
||||
}
|
||||
```
|
||||
|
||||
### Key Rules
|
||||
|
||||
- **`val` properties** must have a `get()` accessor and cannot have a `set()`.
|
||||
- **`var` properties** must have both `get()` and `set()` accessors.
|
||||
- **`val` properties** must have a `get` accessor (with or without parentheses) and cannot have a `set`.
|
||||
- **`var` properties** must have both `get` and `set` accessors.
|
||||
- **Functions and methods** can use the `=` shorthand to return the result of a single expression.
|
||||
- **`override` is mandatory**: If you are overriding a member from a base class, you MUST use the `override` keyword.
|
||||
- **No Backing Fields**: There is no magic `field` identifier. If you need to store state, you must declare a separate (usually `private`) field.
|
||||
- **Type Inference**: You can omit the type declaration if it can be inferred or if you don't need strict typing.
|
||||
|
||||
@@ -427,7 +425,7 @@ Key rules and features:
|
||||
|
||||
- Visibility
|
||||
- `private`: accessible only inside the declaring class body; not visible in subclasses and cannot be accessed via `this@Type` or casts.
|
||||
- `protected`: accessible in the declaring class and in any of its transitive subclasses (including MI), but not from unrelated contexts; qualification/casts do not bypass it.
|
||||
- `protected`: accessible in the declaring class and in any of its transitive subclasses (including MI). Additionally, ancestor classes can access protected members of their descendants if it's an override of a member known to the ancestor. Protected members are not visible from unrelated contexts; qualification/casts do not bypass it.
|
||||
|
||||
## Abstract Classes and Members
|
||||
|
||||
@@ -859,23 +857,44 @@ Private fields are visible only _inside the class instance_:
|
||||
void
|
||||
>>> void
|
||||
|
||||
### Transient fields
|
||||
|
||||
You can mark a field or a constructor parameter as transient using the `@Transient` attribute. Transient members are ignored during serialization (Lynon and JSON) and are also excluded from structural equality (`==`) checks.
|
||||
|
||||
```lyng
|
||||
class Session(@Transient val token, val userId) {
|
||||
@Transient var lastAccess = time.now()
|
||||
var data = Map()
|
||||
}
|
||||
```
|
||||
|
||||
For more details on how transient fields behave during restoration, see the [Serialization Guide](serialization.md).
|
||||
|
||||
### Protected members
|
||||
|
||||
Protected members are available to the declaring class and all of its transitive subclasses (including via MI), but not from unrelated contexts:
|
||||
Protected members are available to the declaring class and all of its transitive subclasses (including via MI). Additionally, an ancestor class can access a `protected` member of its descendant if the ancestor also defines or inherits a member with the same name (i.e., it is an override of something the ancestor knows about).
|
||||
|
||||
```
|
||||
class A() {
|
||||
protected fun ping() { "pong" }
|
||||
}
|
||||
class B() : A() {
|
||||
fun call() { this@A.ping() }
|
||||
Protected members are not available from unrelated contexts:
|
||||
|
||||
```lyng
|
||||
class Base {
|
||||
abstract protected fun foo()
|
||||
|
||||
fun bar() {
|
||||
// Ancestor can see foo() because it's an override
|
||||
// of a member it defines (even as abstract):
|
||||
foo()
|
||||
}
|
||||
}
|
||||
|
||||
val b = B()
|
||||
assertEquals("pong", b.call())
|
||||
class Derived : Base {
|
||||
override protected fun foo() { "ok" }
|
||||
}
|
||||
|
||||
assertEquals("ok", Derived().bar())
|
||||
|
||||
// Unrelated access is forbidden, even via cast
|
||||
assertThrows { (b as A).ping() }
|
||||
assertThrows { (Derived() as Base).foo() }
|
||||
```
|
||||
|
||||
It is possible to provide private constructor parameters so they can be
|
||||
|
||||
+4
-3
@@ -98,10 +98,11 @@ Exclusive end char ranges are supported too:
|
||||
| isEndInclusive | true for '..' | Bool |
|
||||
| isOpen | at any end | Bool |
|
||||
| isIntRange | both start and end are Int | Bool |
|
||||
| start | | Bool |
|
||||
| end | | Bool |
|
||||
| start | | Any? |
|
||||
| end | | Any? |
|
||||
| size | for finite ranges, see above | Long |
|
||||
| [] | see above | |
|
||||
| | | |
|
||||
|
||||
Ranges are also used with the `clamp(value, range)` function and the `value.clamp(range)` extension method to limit values within boundaries.
|
||||
|
||||
[Iterable]: Iterable.md
|
||||
@@ -19,6 +19,7 @@ you can use it's class to ensure type:
|
||||
|-----------------|-------------------------------------------------------------|------|
|
||||
| `.roundToInt()` | round to nearest int like round(x) | Int |
|
||||
| `.toInt()` | convert integer part of real to `Int` dropping decimal part | Int |
|
||||
| `.clamp(range)` | clamp value within range boundaries | Real |
|
||||
| | | |
|
||||
| | | |
|
||||
| | | |
|
||||
|
||||
@@ -103,6 +103,11 @@ scope.addVoidFn("log") {
|
||||
println(items.joinToString(" ") { it.toString(this).value })
|
||||
}
|
||||
|
||||
// When adding a member function to a class, you can use isOverride = true
|
||||
// myClass.addFn("toString", isOverride = true) {
|
||||
// ObjString("Custom string representation")
|
||||
// }
|
||||
|
||||
// Call them from Lyng
|
||||
scope.eval("val y = inc(41); log('Answer:', y)")
|
||||
```
|
||||
@@ -122,6 +127,9 @@ myClass.createField("version", ObjString("1.0.0"), isMutable = false)
|
||||
// Add a mutable field with an initial value
|
||||
myClass.createField("count", ObjInt(0), isMutable = true)
|
||||
|
||||
// If you are overriding a field from a base class, use isOverride = true
|
||||
// myClass.createField("someBaseField", ObjInt(42), isOverride = true)
|
||||
|
||||
scope.addConst("MyClass", myClass)
|
||||
```
|
||||
|
||||
@@ -153,6 +161,16 @@ myClass.addProperty(
|
||||
}
|
||||
)
|
||||
|
||||
// You can also create an ObjProperty explicitly
|
||||
val explicitProp = ObjProperty(
|
||||
name = "hexValue",
|
||||
getter = statement { ObjString(internalValue.toString(16)) }
|
||||
)
|
||||
myClass.addProperty("hexValue", prop = explicitProp)
|
||||
|
||||
// Use isOverride = true when overriding a property from a base class
|
||||
// myClass.addProperty("baseProp", getter = { ... }, isOverride = true)
|
||||
|
||||
scope.addConst("MyClass", myClass)
|
||||
```
|
||||
|
||||
|
||||
@@ -20,7 +20,18 @@ Simple classes serialization is supported:
|
||||
assertEquals( "{\"foo\":1,\"bar\":2}", Point(1,2).toJsonString() )
|
||||
>>> void
|
||||
|
||||
Note that mutable members are serialized:
|
||||
Note that mutable members are serialized by default. You can exclude any member (including constructor parameters) from JSON serialization using the `@Transient` attribute:
|
||||
|
||||
import lyng.serialization
|
||||
|
||||
class Point2(@Transient val foo, val bar) {
|
||||
@Transient var reason = 42
|
||||
var visible = 100
|
||||
}
|
||||
assertEquals( "{\"bar\":2,\"visible\":100}", Point2(1,2).toJsonString() )
|
||||
>>> void
|
||||
|
||||
Note that if you override json serialization:
|
||||
|
||||
import lyng.serialization
|
||||
|
||||
|
||||
@@ -92,6 +92,7 @@ or transformed `Real` otherwise.
|
||||
| pow(x, y) | ${x^y}$ |
|
||||
| sqrt(x) | $ \sqrt {x}$ |
|
||||
| abs(x) | absolute value of x. Int if x is Int, Real otherwise |
|
||||
| clamp(x, range) | limit x to be inside range boundaries |
|
||||
|
||||
For example:
|
||||
|
||||
@@ -102,6 +103,11 @@ For example:
|
||||
// abs() keeps the argument type:
|
||||
assert( abs(-1) is Int)
|
||||
assert( abs(-2.21) == 2.21 )
|
||||
|
||||
// clamp() limits value to the range:
|
||||
assert( clamp(15, 0..10) == 10 )
|
||||
assert( clamp(-5, 0..10) == 0 )
|
||||
assert( 5.clamp(0..10) == 5 )
|
||||
>>> void
|
||||
|
||||
## Scientific constant
|
||||
|
||||
+5
-7
@@ -226,13 +226,11 @@ Future work: introduce thread‑safe pooling (e.g., per‑thread pools or confin
|
||||
|
||||
Closures executed by `launch { ... }` and `flow { ... }` resolve names using the `ClosureScope` rules:
|
||||
|
||||
1. Closure frame locals/arguments
|
||||
2. Captured receiver instance/class members
|
||||
3. Closure ancestry locals + each frame’s `this` members (cycle‑safe)
|
||||
4. Caller `this` members
|
||||
5. Caller ancestry locals + each frame’s `this` members (cycle‑safe)
|
||||
6. Module pseudo‑symbols (e.g., `__PACKAGE__`)
|
||||
7. Direct module/global fallback (nearest `ModuleScope` and its parent/root)
|
||||
1. **Current frame locals and arguments**: Variables defined within the current closure execution.
|
||||
2. **Captured lexical ancestry**: Outer local variables captured at the site where the closure was defined (the "lexical environment").
|
||||
3. **Captured receiver members**: If the closure was defined within a class or explicitly bound to an object, it checks members of that object (`this`), following MRO and respecting visibility.
|
||||
4. **Caller environment**: Falls back to the calling context (e.g., the caller's `this` or local variables).
|
||||
5. **Global/Module fallbacks**: Final check for module-level constants and global functions.
|
||||
|
||||
Implications:
|
||||
- Outer locals (e.g., `counter`) stay visible across suspension points.
|
||||
|
||||
+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.
|
||||
|
||||
@@ -1,7 +1,6 @@
|
||||
#!/bin/env lyng
|
||||
|
||||
import lyng.io.fs
|
||||
import lyng.stdlib
|
||||
|
||||
val files = Path("../..").list().toList()
|
||||
// most long is longest?
|
||||
|
||||
@@ -8,16 +8,13 @@ Name lookup across nested scopes and closures can accidentally form recursive re
|
||||
## Resolution order in ClosureScope
|
||||
When evaluating an identifier `name` inside a closure, `ClosureScope.get(name)` resolves in this order:
|
||||
|
||||
1. Closure frame locals and arguments
|
||||
2. Captured receiver (`closureScope.thisObj`) instance/class members
|
||||
3. Closure ancestry locals + each frame’s `thisObj` members (cycle‑safe)
|
||||
4. Caller `this` members
|
||||
5. Caller ancestry locals + each frame’s `thisObj` members (cycle‑safe)
|
||||
6. Module pseudo‑symbols (e.g., `__PACKAGE__`) from the nearest `ModuleScope`
|
||||
7. Direct module/global fallback (nearest `ModuleScope` and its parent/root scope)
|
||||
8. Final fallback: base local/parent lookup for the current frame
|
||||
1. **Current frame locals and arguments**: Variables defined within the current closure execution.
|
||||
2. **Captured lexical ancestry**: Outer local variables captured at the site where the closure was defined (the "lexical environment").
|
||||
3. **Captured receiver members**: If the closure was defined within a class or explicitly bound to an object, it checks members of that object (`this`). This includes both instance fields/methods and class-level static members, following the MRO (C3) and respecting visibility rules (private members are only visible if the closure was defined in their class).
|
||||
4. **Caller environment**: If not found lexically, it falls back to the calling context (e.g., the DSL's `this` or the caller's local variables).
|
||||
5. **Global/Module fallbacks**: Final check for module-level constants and global functions.
|
||||
|
||||
This preserves intuitive visibility (locals → captured receiver → closure chain → caller members → caller chain → module/root) while preventing infinite recursion between scope types.
|
||||
This ensures that closures primarily interact with their defining environment (lexical capture) while still being able to participate in DSL-style calling contexts.
|
||||
|
||||
## Use raw‑chain helpers for ancestry walks
|
||||
When authoring new scope types or advanced lookups, avoid calling virtual `get` while walking parents. Instead, use the non‑dispatch helpers on `Scope`:
|
||||
|
||||
+25
-8
@@ -20,20 +20,37 @@ It is as simple as:
|
||||
assert( text.length > encodedBits.toBuffer().size )
|
||||
>>> void
|
||||
|
||||
Any class you create is serializable by default; lynon serializes first constructor fields, then any `var` member fields:
|
||||
Any class you create is serializable by default; lynon serializes first constructor fields, then any `var` member fields.
|
||||
|
||||
import lyng.serialization
|
||||
## Transient Fields
|
||||
|
||||
class Point(x,y)
|
||||
Sometimes you have fields that should not be serialized, for example, temporary caches, secret data, or derived values that are recomputed in `init` blocks. You can mark such fields with the `@Transient` attribute:
|
||||
|
||||
val p = Lynon.decode( Lynon.encode( Point(5,6) ) )
|
||||
```lyng
|
||||
class MyData(@Transient val tempSecret, val publicData) {
|
||||
@Transient var cachedValue = 0
|
||||
var persistentValue = 42
|
||||
|
||||
assertEquals( 5, p.x )
|
||||
assertEquals( 6, p.y )
|
||||
>>> void
|
||||
init {
|
||||
// cachedValue can be recomputed here upon deserialization
|
||||
cachedValue = computeCache(publicData)
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Transient fields:
|
||||
- Are **omitted** from Lynon binary streams.
|
||||
- Are **omitted** from JSON output (via `toJson`).
|
||||
- Are **ignored** during structural equality checks (`==`).
|
||||
- If a transient constructor parameter has a **default value**, it will be restored to that default value during deserialization. Otherwise, it will be `null`.
|
||||
- Class body fields marked as `@Transient` will keep their initial values (or values assigned in `init`) after deserialization.
|
||||
|
||||
just as expected.
|
||||
## Serialization of Objects and Classes
|
||||
|
||||
- **Singleton Objects**: `object` declarations are serializable by name. Their state (mutable fields) is also serialized and restored, respecting `@Transient`.
|
||||
- **Classes**: Class objects themselves can be serialized. They are serialized by their full qualified name. When converted to JSON, a class object includes its public static fields (excluding those marked `@Transient`).
|
||||
|
||||
## Custom Serialization
|
||||
|
||||
Important is to understand that normally `Lynon.decode` wants [BitBuffer], as `Lynon.encode` produces. If you have the regular [Buffer], be sure to convert it:
|
||||
|
||||
|
||||
+75
-136
@@ -2,166 +2,105 @@
|
||||
|
||||
Lyng date and time support requires importing `lyng.time` packages. Lyng uses simple yet modern time object models:
|
||||
|
||||
- `Instant` class for time stamps with platform-dependent resolution
|
||||
- `Duration` to represent amount of time not depending on the calendar, e.g. in absolute units (milliseconds, seconds,
|
||||
hours, days)
|
||||
- `Instant` class for absolute time stamps with platform-dependent resolution.
|
||||
- `DateTime` class for calendar-aware points in time within a specific time zone.
|
||||
- `Duration` to represent amount of time not depending on the calendar (e.g., milliseconds, seconds).
|
||||
|
||||
## Time instant: `Instant`
|
||||
|
||||
Represent some moment of time not depending on the calendar (calendar for example may b e changed, daylight saving time
|
||||
can be for example introduced or dropped). It is similar to `TIMESTAMP` in SQL or `Instant` in Kotlin. Some moment of
|
||||
time; not the calendar date.
|
||||
Represent some moment of time not depending on the calendar. It is similar to `TIMESTAMP` in SQL or `Instant` in Kotlin.
|
||||
|
||||
Instant is comparable to other Instant. Subtracting instants produce `Duration`, period in time that is not dependent on
|
||||
the calendar, e.g. absolute time period.
|
||||
|
||||
It is possible to add or subtract `Duration` to and from `Instant`, that gives another `Instant`.
|
||||
|
||||
Instants are converted to and from `Real` number of seconds before or after Unix Epoch, 01.01.1970. Constructor with
|
||||
single number parameter constructs from such number of seconds,
|
||||
and any instance provide `.epochSeconds` member:
|
||||
### Constructing and converting
|
||||
|
||||
import lyng.time
|
||||
|
||||
// default constructor returns time now:
|
||||
val t1 = Instant()
|
||||
val t2 = Instant()
|
||||
assert( t2 - t1 < 1.millisecond )
|
||||
assert( t2.epochSeconds - t1.epochSeconds < 0.001 )
|
||||
>>> void
|
||||
|
||||
## Constructing
|
||||
|
||||
import lyng.time
|
||||
|
||||
// empty constructor gives current time instant using system clock:
|
||||
val now = Instant()
|
||||
|
||||
// constructor with Instant instance makes a copy:
|
||||
assertEquals( now, Instant(now) )
|
||||
|
||||
// constructing from a number is trated as seconds since unix epoch:
|
||||
val copyOfNow = Instant( now.epochSeconds )
|
||||
|
||||
// note that instant resolution is higher that Real can hold
|
||||
// so reconstructed from real slightly differs:
|
||||
assert( abs( (copyOfNow - now).milliseconds ) < 0.01 )
|
||||
>>> void
|
||||
|
||||
The resolution of system clock could be more precise and double precision real number of `Real`, keep it in mind.
|
||||
|
||||
## Comparing and calculating periods
|
||||
|
||||
import lyng.time
|
||||
|
||||
val now = Instant()
|
||||
// constructing from a number is treated as seconds since unix epoch:
|
||||
val t2 = Instant(1704110400) // 2024-01-01T12:00:00Z
|
||||
|
||||
// you cam add or subtract periods, and compare
|
||||
assert( now - 5.minutes < now )
|
||||
val oneHourAgo = now - 1.hour
|
||||
assertEquals( now, oneHourAgo + 1.hour)
|
||||
// from RFC3339 string:
|
||||
val t3 = Instant("2024-01-01T12:00:00.123456Z")
|
||||
|
||||
// truncation:
|
||||
val t4 = t3.truncateToMinute
|
||||
assertEquals(t4.toRFC3339(), "2024-01-01T12:00:00Z")
|
||||
|
||||
// to localized DateTime (uses system default TZ if not specified):
|
||||
val dt = t3.toDateTime("+02:00")
|
||||
assertEquals(dt.hour, 14)
|
||||
|
||||
>>> void
|
||||
|
||||
## Getting the max precision
|
||||
|
||||
Normally, subtracting instants gives precision to microseconds, which is well inside the jitter
|
||||
the language VM adds. Still `Instant()` or `Instant.now()` capture most precise system timer at hand and provide inner
|
||||
value of 12 bytes, up to nanoseconds (hopefully). To access it use:
|
||||
|
||||
import lyng.time
|
||||
|
||||
// capture time
|
||||
val now = Instant.now()
|
||||
|
||||
// this is Int value, number of whole epoch
|
||||
// milliseconds to the moment, it fits 8 bytes Int well
|
||||
val seconds = now.epochWholeSeconds
|
||||
assert(seconds is Int)
|
||||
|
||||
// and this is Int value of nanoseconds _since_ the epochMillis,
|
||||
// it effectively add 4 more mytes int:
|
||||
val nanos = now.nanosecondsOfSecond
|
||||
assert(nanos is Int)
|
||||
assert( nanos in 0..999_999_999 )
|
||||
|
||||
// we can construct epochSeconds from these parts:
|
||||
assertEquals( now.epochSeconds, nanos * 1e-9 + seconds )
|
||||
>>> void
|
||||
|
||||
## Truncating to more realistic precision
|
||||
|
||||
Full precision Instant is way too long and impractical to store, especially when serializing,
|
||||
so it is possible to truncate it to milliseconds, microseconds or seconds:
|
||||
|
||||
import lyng.time
|
||||
import lyng.serialization
|
||||
|
||||
// max supported size (now microseconds for serialized value):
|
||||
// note that encoding return _bit array_ and this is a _bit size_:
|
||||
val s0 = Lynon.encode(Instant.now()).size
|
||||
|
||||
// shorter: milliseconds only
|
||||
val s1 = Lynon.encode(Instant.now().truncateToMillisecond()).size
|
||||
|
||||
// truncated to seconds, good for file mtime, etc:
|
||||
val s2 = Lynon.encode(Instant.now().truncateToSecond()).size
|
||||
assert( s1 < s0 )
|
||||
assert( s2 < s1 )
|
||||
>>> void
|
||||
|
||||
## Formatting instants
|
||||
|
||||
You can freely use `Instant` in string formatting. It supports usual sprintf-style formats:
|
||||
|
||||
import lyng.time
|
||||
val now = Instant()
|
||||
|
||||
// will be something like "now: 12:10:05"
|
||||
val currentTimeOnly24 = "now: %tT"(now)
|
||||
|
||||
// we can extract epoch second with formatting too,
|
||||
// this was since early C time
|
||||
|
||||
// get epoch while seconds from formatting
|
||||
val unixEpoch = "Now is %ts since unix epoch"(now)
|
||||
|
||||
// and it is the same as now.epochSeconds, int part:
|
||||
assertEquals( unixEpoch, "Now is %d since unix epoch"(now.epochSeconds.toInt()) )
|
||||
>>> void
|
||||
|
||||
See
|
||||
the [complete list of available formats](https://github.com/sergeych/mp_stools?tab=readme-ov-file#datetime-formatting)
|
||||
and the [formatting reference](https://github.com/sergeych/mp_stools?tab=readme-ov-file#printf--sprintf): it all works
|
||||
in Lyng as `"format"(args...)`!
|
||||
|
||||
## Instant members
|
||||
### Instant members
|
||||
|
||||
| member | description |
|
||||
|--------------------------------|---------------------------------------------------------|
|
||||
| epochSeconds: Real | positive or negative offset in seconds since Unix epoch |
|
||||
| epochWholeSeconds: Int | same, but in _whole seconds_. Slightly faster |
|
||||
| nanosecondsOfSecond: Int | offset from epochWholeSeconds in nanos (1) |
|
||||
| nanosecondsOfSecond: Int | offset from epochWholeSeconds in nanos |
|
||||
| isDistantFuture: Bool | true if it `Instant.distantFuture` |
|
||||
| isDistantPast: Bool | true if it `Instant.distantPast` |
|
||||
| truncateToSecond: Intant | create new instnce truncated to second |
|
||||
| truncateToMillisecond: Instant | truncate new instance with to millisecond |
|
||||
| truncateToMinute: Instant | create new instance truncated to minute |
|
||||
| truncateToSecond: Instant | create new instance truncated to second |
|
||||
| truncateToMillisecond: Instant | truncate new instance to millisecond |
|
||||
| truncateToMicrosecond: Instant | truncate new instance to microsecond |
|
||||
| toRFC3339(): String | format as RFC3339 string (UTC) |
|
||||
| toDateTime(tz?): DateTime | localize to a TimeZone (ID string or offset seconds) |
|
||||
|
||||
(1)
|
||||
: The value of nanoseconds is to be added to `epochWholeSeconds` to get exact time point. It is in 0..999_999_999 range.
|
||||
The precise time instant value therefore needs as for now 12 bytes integer; we might use bigint later (it is planned to
|
||||
be added)
|
||||
## Calendar time: `DateTime`
|
||||
|
||||
## Class members
|
||||
`DateTime` represents a point in time in a specific timezone. It provides access to calendar components like year,
|
||||
month, and day.
|
||||
|
||||
| member | description |
|
||||
|--------------------------------|----------------------------------------------|
|
||||
| Instant.now() | create new instance with current system time |
|
||||
| Instant.distantPast: Instant | most distant instant in past |
|
||||
| Instant.distantFuture: Instant | most distant instant in future |
|
||||
### Constructing
|
||||
|
||||
# `Duraion` class
|
||||
import lyng.time
|
||||
|
||||
// Current time in system default timezone
|
||||
val now = DateTime.now()
|
||||
|
||||
// Specific timezone
|
||||
val offsetTime = DateTime.now("+02:00")
|
||||
|
||||
// From Instant
|
||||
val dt = Instant().toDateTime("Z")
|
||||
|
||||
// By components (year, month, day, hour=0, minute=0, second=0, timeZone="UTC")
|
||||
val dt2 = DateTime(2024, 1, 1, 12, 0, 0, "Z")
|
||||
|
||||
// From RFC3339 string
|
||||
val dt3 = DateTime.parseRFC3339("2024-01-01T12:00:00+02:00")
|
||||
|
||||
### DateTime members
|
||||
|
||||
| member | description |
|
||||
|----------------------------------|-----------------------------------------------|
|
||||
| year: Int | year component |
|
||||
| month: Int | month component (1..12) |
|
||||
| day: Int | day of month (alias `dayOfMonth`) |
|
||||
| hour: Int | hour component (0..23) |
|
||||
| minute: Int | minute component (0..59) |
|
||||
| second: Int | second component (0..59) |
|
||||
| dayOfWeek: Int | day of week (1=Monday, 7=Sunday) |
|
||||
| timeZone: String | timezone ID string |
|
||||
| toInstant(): Instant | convert back to absolute Instant |
|
||||
| toUTC(): DateTime | shortcut to convert to UTC |
|
||||
| toTimeZone(tz): DateTime | convert to another timezone |
|
||||
| addMonths(n): DateTime | add/subtract months (normalizes end of month) |
|
||||
| addYears(n): DateTime | add/subtract years |
|
||||
| toRFC3339(): String | format with timezone offset |
|
||||
| static now(tz?): DateTime | create DateTime with current time |
|
||||
| static parseRFC3339(s): DateTime | parse RFC3339 string |
|
||||
|
||||
### Arithmetic and normalization
|
||||
|
||||
`DateTime` handles calendar arithmetic correctly:
|
||||
|
||||
val leapDay = Instant("2024-02-29T12:00:00Z").toDateTime("Z")
|
||||
val nextYear = leapDay.addYears(1)
|
||||
assertEquals(nextYear.day, 28) // Feb 29, 2024 -> Feb 28, 2025
|
||||
|
||||
# `Duration` class
|
||||
|
||||
Represent absolute time distance between two `Instant`.
|
||||
|
||||
|
||||
+13
-4
@@ -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,13 +1471,22 @@ 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 |
|
||||
|----------------------|------------------------------------------------------------|
|
||||
| lower(), lowercase() | change case to unicode upper |
|
||||
| upper(), uppercase() | change case to unicode lower |
|
||||
| trim() | trim space chars from both ends |
|
||||
| isEmpty() | true if string is empty |
|
||||
| isNotEmpty() | true if string is not empty |
|
||||
| isBlank() | true if empty or contains only whitespace |
|
||||
| startsWith(prefix) | true if starts with a prefix |
|
||||
| endsWith(prefix) | true if ends with a prefix |
|
||||
| last() | get last character of a string or throw |
|
||||
@@ -1494,7 +1503,7 @@ Typical set of String functions includes:
|
||||
| s1 += s2 | self-modifying concatenation |
|
||||
| toReal() | attempts to parse string as a Real value |
|
||||
| toInt() | parse string to Int value |
|
||||
| characters() | create [List] of characters (1) |
|
||||
| characters | create [List] of characters (1) |
|
||||
| encodeUtf8() | returns [Buffer] with characters encoded to utf8 |
|
||||
| matches(re) | matches the regular expression (2) |
|
||||
| | |
|
||||
@@ -1695,7 +1704,7 @@ assertEquals(null, (buzz as? Foo)?.runA())
|
||||
|
||||
Notes:
|
||||
- Resolution order uses C3 MRO (active): deterministic, monotonic order suitable for diamonds and complex hierarchies. Example: for `class D() : B(), C()` where both `B()` and `C()` derive from `A()`, the C3 order is `D → B → C → A`. The first visible match wins.
|
||||
- `private` is visible only inside the declaring class; `protected` is visible from the declaring class and any of its transitive subclasses. Qualialsofication (`this@Type`) or casts do not bypass visibility.
|
||||
- `private` is visible only inside the declaring class; `protected` is visible from the declaring class and its subclasses. Additionally, ancestors can access protected members of descendants if they override a member known to the ancestor. Qualification (`this@Type`) or casts do not bypass visibility.
|
||||
- Safe‑call `?.` works with `as?` for optional dispatch.
|
||||
|
||||
## Extension members
|
||||
|
||||
@@ -24,6 +24,9 @@ class Person(private var _age: Int) {
|
||||
### Private and Protected Setters
|
||||
You can now restrict the visibility of a property's or field's setter using `private set` or `protected set`. This allows members to be publicly readable but only writable from within the declaring class or its subclasses.
|
||||
|
||||
### Refined Protected Visibility
|
||||
Ancestor classes can now access `protected` members of their descendants if it is an override of a member known to the ancestor. This enables base classes to call protected methods that are implemented or overridden in subclasses.
|
||||
|
||||
```lyng
|
||||
class Counter {
|
||||
var count = 0
|
||||
@@ -168,6 +171,41 @@ settings["theme"] ?= "dark"
|
||||
|
||||
The operator returns the final value of the receiver (the original value if it was not `null`, or the new value if the assignment occurred).
|
||||
|
||||
### Transient Attribute (`@Transient`)
|
||||
The `@Transient` attribute can now be applied to class fields, constructor parameters, and static fields to exclude them from serialization.
|
||||
|
||||
```lyng
|
||||
class MyData(@Transient val tempSecret, val publicData) {
|
||||
@Transient var cachedValue = 0
|
||||
var persistentValue = 42
|
||||
}
|
||||
```
|
||||
|
||||
Key features:
|
||||
- **Serialization**: Transient members are omitted from both Lynon binary streams and JSON output.
|
||||
- **Structural Equality**: Transient fields are automatically ignored during `==` equality checks.
|
||||
- **Deserialization**: Transient constructor parameters with default values are correctly restored to those defaults upon restoration.
|
||||
|
||||
### Value Clamping (`clamp`)
|
||||
A new `clamp()` function has been added to the standard library to limit a value within a specified range. It is available as both a global function and an extension method on all objects.
|
||||
|
||||
```lyng
|
||||
// Global function
|
||||
clamp(15, 0..10) // returns 10
|
||||
clamp(-5, 0..10) // returns 0
|
||||
|
||||
// Extension method
|
||||
val x = 15
|
||||
x.clamp(0..10) // returns 10
|
||||
|
||||
// Exclusive and open-ended ranges
|
||||
15.clamp(0..<10) // returns 9
|
||||
15.clamp(..10) // returns 10
|
||||
-5.clamp(0..) // returns 0
|
||||
```
|
||||
|
||||
`clamp()` correctly handles inclusive (`..`) and exclusive (`..<`) ranges. For discrete types like `Int` and `Char`, clamping to an exclusive upper bound returns the previous value.
|
||||
|
||||
## Tooling and Infrastructure
|
||||
|
||||
### CLI: Formatting Command
|
||||
|
||||
@@ -5,6 +5,7 @@ kotlin = "2.3.0"
|
||||
android-minSdk = "24"
|
||||
android-compileSdk = "34"
|
||||
kotlinx-coroutines = "1.10.2"
|
||||
kotlinx-datetime = "0.6.1"
|
||||
mp_bintools = "0.3.2"
|
||||
firebaseCrashlyticsBuildtools = "3.0.3"
|
||||
okioVersion = "3.10.2"
|
||||
@@ -16,6 +17,7 @@ clikt-markdown = { module = "com.github.ajalt.clikt:clikt-markdown", version.ref
|
||||
kotlin-test = { module = "org.jetbrains.kotlin:kotlin-test", version.ref = "kotlin" }
|
||||
kotlinx-coroutines-test = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-test", version.ref = "kotlinx-coroutines" }
|
||||
kotlinx-coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "kotlinx-coroutines" }
|
||||
kotlinx-datetime = { module = "org.jetbrains.kotlinx:kotlinx-datetime", version.ref = "kotlinx-datetime" }
|
||||
mp_bintools = { module = "net.sergeych:mp_bintools", version.ref = "mp_bintools" }
|
||||
firebase-crashlytics-buildtools = { group = "com.google.firebase", name = "firebase-crashlytics-buildtools", version.ref = "firebaseCrashlyticsBuildtools" }
|
||||
okio = { module = "com.squareup.okio:okio", version.ref = "okioVersion" }
|
||||
|
||||
@@ -0,0 +1,9 @@
|
||||
This is a branch with a kotlin compiler bug problem
|
||||
|
||||
The problem is: the code built for wasmJS target does not load (tests does not load),
|
||||
the runtime error shows incorrect wasm binary content; $80 AI attempt to investigate
|
||||
it results that most probable source of the bug is bad compilation of the _anonymous suspending lambda expressions_.
|
||||
|
||||
Sorry to say it is one of most used constructions in the Lyng compiler.
|
||||
|
||||
So we have to suspend wasmJS development.
|
||||
@@ -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"
|
||||
}
|
||||
}
|
||||
}
|
||||
+96
-32
@@ -139,7 +139,7 @@ class LyngDocumentationProvider : AbstractDocumentationProvider() {
|
||||
val e: Int = miniSource.offsetOf(d.range.end)
|
||||
if (offset >= s && offset <= e) {
|
||||
// For enum constant, we don't have detailed docs in MiniAst yet, but we can render a title
|
||||
return "<div class='doc-title'>enum constant ${d.name}.${name}</div>"
|
||||
return renderTitle("enum constant ${d.name}.${name}")
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -361,7 +361,7 @@ class LyngDocumentationProvider : AbstractDocumentationProvider() {
|
||||
"Print values to the standard output and append a newline. Accepts any number of arguments." else
|
||||
"Print values to the standard output without a trailing newline. Accepts any number of arguments."
|
||||
val title = "function $ident(values)"
|
||||
return "<div class='doc-title'>${htmlEscape(title)}</div>" + styledMarkdown(htmlEscape(fallback))
|
||||
return renderTitle(title) + styledMarkdown(htmlEscape(fallback))
|
||||
}
|
||||
// 4b) try class members like ClassName.member with inheritance fallback
|
||||
val lhs = previousWordBefore(text, idRange.startOffset)
|
||||
@@ -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(renderTitle(title))
|
||||
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(renderTitle(title))
|
||||
|
||||
// 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(renderTitle(title))
|
||||
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(renderTitle(title))
|
||||
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 {
|
||||
@@ -568,6 +579,10 @@ class LyngDocumentationProvider : AbstractDocumentationProvider() {
|
||||
return "(${params})${ret}"
|
||||
}
|
||||
|
||||
private fun renderTitle(title: String): String {
|
||||
return "<div class='doc-title' style='margin-bottom: 0.8em;'>${htmlEscape(title)}</div>"
|
||||
}
|
||||
|
||||
private fun htmlEscape(s: String): String = buildString(s.length) {
|
||||
for (ch in s) append(
|
||||
when (ch) {
|
||||
@@ -634,7 +649,7 @@ class LyngDocumentationProvider : AbstractDocumentationProvider() {
|
||||
|
||||
private fun renderOverloads(name: String, overloads: List<MiniFunDecl>): String {
|
||||
val sb = StringBuilder()
|
||||
sb.append("<div class='doc-title'>Overloads for ").append(htmlEscape(name)).append("</div>")
|
||||
sb.append(renderTitle("Overloads for $name"))
|
||||
sb.append("<ul>")
|
||||
overloads.forEach { fn ->
|
||||
sb.append("<li><code>")
|
||||
@@ -656,6 +671,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
|
||||
@@ -120,12 +121,39 @@ class LyngLexer : LexerBase() {
|
||||
|
||||
// Number
|
||||
if (ch.isDigit()) {
|
||||
// Check for hex: 0x...
|
||||
if (ch == '0' && i + 1 < endOffset && buffer[i + 1] == 'x') {
|
||||
i += 2
|
||||
while (i < endOffset && (buffer[i].isDigit() || buffer[i] in 'a'..'f' || buffer[i] in 'A'..'F')) i++
|
||||
myTokenEnd = i
|
||||
myTokenType = LyngTokenTypes.NUMBER
|
||||
return
|
||||
}
|
||||
|
||||
// Decimal or integer
|
||||
i++
|
||||
var hasDot = false
|
||||
var hasE = false
|
||||
while (i < endOffset) {
|
||||
val c = buffer[i]
|
||||
if (c.isDigit()) { i++; continue }
|
||||
if (c == '.' && !hasDot) { hasDot = true; i++; continue }
|
||||
if (c.isDigit() || c == '_') {
|
||||
i++
|
||||
continue
|
||||
}
|
||||
if (c == '.' && !hasDot && !hasE) {
|
||||
// Check if it's a fractional part (must be followed by a digit)
|
||||
if (i + 1 < endOffset && buffer[i + 1].isDigit()) {
|
||||
hasDot = true
|
||||
i++
|
||||
continue
|
||||
}
|
||||
}
|
||||
if ((c == 'e' || c == 'E') && !hasE) {
|
||||
hasE = true
|
||||
i++
|
||||
if (i < endOffset && (buffer[i] == '+' || buffer[i] == '-')) i++
|
||||
continue
|
||||
}
|
||||
break
|
||||
}
|
||||
myTokenEnd = i
|
||||
@@ -160,6 +188,35 @@ class LyngLexer : LexerBase() {
|
||||
// Punctuation
|
||||
if (isPunct(ch)) {
|
||||
i++
|
||||
// Handle common multi-char operators for better highlighting
|
||||
when (ch) {
|
||||
'.' -> {
|
||||
if (i < endOffset && buffer[i] == '.') {
|
||||
i++
|
||||
if (i < endOffset && (buffer[i] == '.' || buffer[i] == '<')) i++
|
||||
}
|
||||
}
|
||||
'=' -> {
|
||||
if (i < endOffset && (buffer[i] == '=' || buffer[i] == '>' || buffer[i] == '~')) {
|
||||
i++
|
||||
if (buffer[i - 1] == '=' && i < endOffset && buffer[i] == '=') i++
|
||||
}
|
||||
}
|
||||
'+', '-', '*', '/', '%', '!', '<', '>', '&', '|', '?', ':', '^' -> {
|
||||
if (i < endOffset) {
|
||||
val next = buffer[i]
|
||||
if (next == '=' || next == ch) {
|
||||
i++
|
||||
if (ch == '<' && next == '=' && i < endOffset && buffer[i] == '>') i++
|
||||
if (ch == '!' && next == '=' && i < endOffset && buffer[i] == '=') i++
|
||||
} else if (ch == '?' && (next == '.' || next == '[' || next == '(' || next == '{' || next == ':' || next == '?')) {
|
||||
i++
|
||||
} else if (ch == '-' && next == '>') {
|
||||
i++
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
myTokenEnd = i
|
||||
myTokenType = LyngTokenTypes.PUNCT
|
||||
return
|
||||
|
||||
+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.1.1-SNAPSHOT"
|
||||
version = "1.2.1-SNAPSHOT"
|
||||
|
||||
// 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")
|
||||
@@ -96,6 +97,7 @@ kotlin {
|
||||
kotlin.srcDir("$buildDir/generated/buildConfig/commonMain/kotlin")
|
||||
dependencies {
|
||||
implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.9.0")
|
||||
implementation("org.jetbrains.kotlinx:kotlinx-datetime:0.6.1")
|
||||
//put your multiplatform dependencies here
|
||||
api(libs.kotlinx.coroutines.core)
|
||||
api(libs.mp.bintools)
|
||||
|
||||
@@ -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,12 +51,40 @@ 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,
|
||||
isTransient = a.isTransient)
|
||||
}
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
fun assign(a: Item, value: Obj) {
|
||||
scope.addItem(a.name, (a.accessType ?: defaultAccessType).isMutable,
|
||||
value.byValueCopy(),
|
||||
a.visibility ?: defaultVisibility,
|
||||
recordType = ObjRecord.Type.Argument,
|
||||
declaringClass = declaringClass)
|
||||
declaringClass = declaringClass,
|
||||
isTransient = a.isTransient)
|
||||
}
|
||||
|
||||
// Prepare positional args and parameter count, handle tail-block binding
|
||||
@@ -213,5 +241,6 @@ data class ArgsDeclaration(val params: List<Item>, val endTokenType: Token.Type)
|
||||
val defaultValue: Statement? = null,
|
||||
val accessType: AccessType? = null,
|
||||
val visibility: Visibility? = null,
|
||||
val isTransient: Boolean = false,
|
||||
)
|
||||
}
|
||||
@@ -17,6 +17,8 @@
|
||||
|
||||
package net.sergeych.lyng
|
||||
|
||||
import net.sergeych.lyng.obj.Obj
|
||||
import net.sergeych.lyng.obj.ObjClass
|
||||
import net.sergeych.lyng.obj.ObjRecord
|
||||
|
||||
/**
|
||||
@@ -38,138 +40,34 @@ class ClosureScope(val callScope: Scope, val closureScope: Scope) :
|
||||
}
|
||||
|
||||
override fun get(name: String): ObjRecord? {
|
||||
// Fast-path built-ins
|
||||
if (name == "this") return thisObj.asReadonly
|
||||
|
||||
// Priority:
|
||||
// 1) Locals and arguments declared in this lambda frame (including values defined before suspension)
|
||||
// 2) Instance/class members of the captured receiver (`closureScope.thisObj`)
|
||||
// 3) Symbols from the captured closure scope chain (locals/parents), ignoring nested ClosureScope overrides
|
||||
// 4) Instance members of the caller's `this` (e.g., FlowBuilder.emit)
|
||||
// 5) Symbols from the caller chain (locals/parents), ignoring nested ClosureScope overrides
|
||||
// 6) Special fallback for module pseudo-symbols (e.g., __PACKAGE__)
|
||||
// 1. Current frame locals (parameters, local variables)
|
||||
tryGetLocalRecord(this, name, currentClassCtx)?.let { return it }
|
||||
|
||||
// 1) Locals/arguments in this closure frame
|
||||
super.objects[name]?.let { return it }
|
||||
super.localBindings[name]?.let { return it }
|
||||
// 2. Lexical environment (captured locals from entire ancestry)
|
||||
closureScope.chainLookupIgnoreClosure(name, followClosure = true, caller = currentClassCtx)?.let { return it }
|
||||
|
||||
// 1a) Priority: if we are in a class context, prefer our own private members to support
|
||||
// non-virtual private dispatch. This prevents a subclass from accidentally
|
||||
// capturing a private member call from a base class.
|
||||
// We only return non-field/non-property members (methods) here; fields must
|
||||
// be resolved via instance storage in priority 2.
|
||||
currentClassCtx?.let { ctx ->
|
||||
ctx.members[name]?.let { rec ->
|
||||
if (rec.visibility == Visibility.Private &&
|
||||
rec.type != net.sergeych.lyng.obj.ObjRecord.Type.Field &&
|
||||
rec.type != net.sergeych.lyng.obj.ObjRecord.Type.Property) return rec
|
||||
}
|
||||
}
|
||||
|
||||
// 1b) Captured locals from the entire closure ancestry. This ensures that parameters
|
||||
// and local variables shadow members of captured receivers, matching standard
|
||||
// lexical scoping rules.
|
||||
closureScope.chainLookupIgnoreClosure(name, followClosure = true)?.let { return it }
|
||||
|
||||
// 2) Members on the captured receiver instance
|
||||
(closureScope.thisObj as? net.sergeych.lyng.obj.ObjInstance)?.let { inst ->
|
||||
// Check direct locals in instance scope (unmangled)
|
||||
inst.instanceScope.objects[name]?.let { rec ->
|
||||
if (rec.type != net.sergeych.lyng.obj.ObjRecord.Type.Property &&
|
||||
canAccessMember(rec.visibility, rec.declaringClass, currentClassCtx)) return rec
|
||||
}
|
||||
// Check mangled names for fields along MRO
|
||||
for (cls in inst.objClass.mro) {
|
||||
inst.instanceScope.objects["${cls.className}::$name"]?.let { rec ->
|
||||
if (rec.type != net.sergeych.lyng.obj.ObjRecord.Type.Property &&
|
||||
canAccessMember(rec.visibility, rec.declaringClass ?: cls, currentClassCtx)) return rec
|
||||
// 3. Lexical this members (captured receiver)
|
||||
val receiver = thisObj
|
||||
val effectiveClass = receiver as? ObjClass ?: receiver.objClass
|
||||
for (cls in effectiveClass.mro) {
|
||||
val rec = cls.members[name] ?: cls.classScope?.objects?.get(name)
|
||||
if (rec != null && !rec.isAbstract) {
|
||||
if (canAccessMember(rec.visibility, rec.declaringClass ?: cls, currentClassCtx, name)) {
|
||||
return rec.copy(receiver = receiver)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
findExtension(closureScope.thisObj.objClass, name)?.let { return it }
|
||||
closureScope.thisObj.objClass.getInstanceMemberOrNull(name)?.let { rec ->
|
||||
if (canAccessMember(rec.visibility, rec.declaringClass, currentClassCtx)) {
|
||||
// Return only non-field/non-property members (methods) from class-level records.
|
||||
// Fields and properties must be resolved via instance storage (mangled) or readField.
|
||||
if (rec.type != net.sergeych.lyng.obj.ObjRecord.Type.Field &&
|
||||
rec.type != net.sergeych.lyng.obj.ObjRecord.Type.Property &&
|
||||
!rec.isAbstract) return rec
|
||||
// Finally, root object fallback
|
||||
Obj.rootObjectType.members[name]?.let { rec ->
|
||||
if (canAccessMember(rec.visibility, rec.declaringClass, currentClassCtx, name)) {
|
||||
return rec.copy(receiver = receiver)
|
||||
}
|
||||
}
|
||||
|
||||
// 3) Closure scope chain (locals/parents + members), ignore ClosureScope overrides to prevent recursion
|
||||
closureScope.chainLookupWithMembers(name, currentClassCtx, followClosure = true)?.let { return it }
|
||||
|
||||
// 4) Caller `this` members
|
||||
(callScope.thisObj as? net.sergeych.lyng.obj.ObjInstance)?.let { inst ->
|
||||
// Check direct locals in instance scope (unmangled)
|
||||
inst.instanceScope.objects[name]?.let { rec ->
|
||||
if (rec.type != net.sergeych.lyng.obj.ObjRecord.Type.Property &&
|
||||
canAccessMember(rec.visibility, rec.declaringClass, currentClassCtx)) return rec
|
||||
}
|
||||
// Check mangled names for fields along MRO
|
||||
for (cls in inst.objClass.mro) {
|
||||
inst.instanceScope.objects["${cls.className}::$name"]?.let { rec ->
|
||||
if (rec.type != net.sergeych.lyng.obj.ObjRecord.Type.Property &&
|
||||
canAccessMember(rec.visibility, rec.declaringClass ?: cls, currentClassCtx)) return rec
|
||||
}
|
||||
}
|
||||
}
|
||||
findExtension(callScope.thisObj.objClass, name)?.let { return it }
|
||||
callScope.thisObj.objClass.getInstanceMemberOrNull(name)?.let { rec ->
|
||||
if (canAccessMember(rec.visibility, rec.declaringClass, currentClassCtx)) {
|
||||
if (rec.type != net.sergeych.lyng.obj.ObjRecord.Type.Field &&
|
||||
rec.type != net.sergeych.lyng.obj.ObjRecord.Type.Property &&
|
||||
!rec.isAbstract) return rec
|
||||
}
|
||||
}
|
||||
|
||||
// 5) Caller chain (locals/parents + members)
|
||||
callScope.chainLookupWithMembers(name, currentClassCtx)?.let { return it }
|
||||
|
||||
// 6) Module pseudo-symbols (e.g., __PACKAGE__) — walk caller ancestry and query ModuleScope directly
|
||||
if (name.startsWith("__")) {
|
||||
var s: Scope? = callScope
|
||||
val visited = HashSet<Long>(4)
|
||||
while (s != null) {
|
||||
if (!visited.add(s.frameId)) break
|
||||
if (s is ModuleScope) return s.get(name)
|
||||
s = s.parent
|
||||
}
|
||||
}
|
||||
|
||||
// 7) Direct module/global fallback: try to locate nearest ModuleScope and check its own locals
|
||||
fun lookupInModuleAncestry(from: Scope): ObjRecord? {
|
||||
var s: Scope? = from
|
||||
val visited = HashSet<Long>(4)
|
||||
while (s != null) {
|
||||
if (!visited.add(s.frameId)) break
|
||||
if (s is ModuleScope) {
|
||||
s.objects[name]?.let { return it }
|
||||
s.localBindings[name]?.let { return it }
|
||||
// check immediate parent (root scope) locals/constants for globals like `delay`
|
||||
val p = s.parent
|
||||
if (p != null) {
|
||||
p.objects[name]?.let { return it }
|
||||
p.localBindings[name]?.let { return it }
|
||||
p.thisObj.objClass.getInstanceMemberOrNull(name)?.let { return it }
|
||||
}
|
||||
return null
|
||||
}
|
||||
s = s.parent
|
||||
}
|
||||
return null
|
||||
}
|
||||
|
||||
lookupInModuleAncestry(closureScope)?.let { return it }
|
||||
lookupInModuleAncestry(callScope)?.let { return it }
|
||||
|
||||
// 8) Global root scope constants/functions (e.g., delay, yield) via current import provider
|
||||
runCatching { this.currentImportProvider.rootScope.objects[name] }.getOrNull()?.let { return it }
|
||||
|
||||
// Final safe fallback: base scope lookup from this frame walking raw parents
|
||||
return baseGetIgnoreClosure(name)
|
||||
// 4. Call environment (caller locals, caller this, and global fallback)
|
||||
return callScope.get(name)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -116,14 +116,30 @@ 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
|
||||
}
|
||||
|
||||
private fun nextNonWhitespace(): Token {
|
||||
while (true) {
|
||||
val t = cc.next()
|
||||
when (t.type) {
|
||||
Token.Type.SINGLE_LINE_COMMENT, Token.Type.MULTILINE_COMMENT -> {
|
||||
pushPendingDocToken(t)
|
||||
}
|
||||
|
||||
Token.Type.NEWLINE -> {
|
||||
if (!prevWasComment) clearPendingDoc() else prevWasComment = false
|
||||
}
|
||||
|
||||
Token.Type.EOF -> return t
|
||||
else -> return t
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Set just before entering a declaration parse, taken from keyword token position
|
||||
private var pendingDeclStart: Pos? = null
|
||||
private var pendingDeclDoc: MiniDoc? = null
|
||||
@@ -169,9 +185,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
|
||||
@@ -285,11 +301,13 @@ class Compiler(
|
||||
}
|
||||
|
||||
private var lastAnnotation: (suspend (Scope, ObjString, Statement) -> Statement)? = null
|
||||
private var isTransientFlag: Boolean = false
|
||||
private var lastLabel: String? = null
|
||||
|
||||
private suspend fun parseStatement(braceMeansLambda: Boolean = false): Statement? {
|
||||
lastAnnotation = null
|
||||
lastLabel = null
|
||||
isTransientFlag = false
|
||||
while (true) {
|
||||
val t = cc.next()
|
||||
return when (t.type) {
|
||||
@@ -308,6 +326,10 @@ class Compiler(
|
||||
|
||||
Token.Type.ATLABEL -> {
|
||||
val label = t.value
|
||||
if (label == "Transient") {
|
||||
isTransientFlag = true
|
||||
continue
|
||||
}
|
||||
if (cc.peekNextNonWhitespace().type == Token.Type.LBRACE) {
|
||||
lastLabel = label
|
||||
}
|
||||
@@ -316,9 +338,15 @@ 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 -> {
|
||||
pushPendingDocToken(t)
|
||||
continue
|
||||
}
|
||||
|
||||
Token.Type.NEWLINE -> continue
|
||||
Token.Type.NEWLINE -> {
|
||||
if (!prevWasComment) clearPendingDoc() else prevWasComment = false
|
||||
continue
|
||||
}
|
||||
|
||||
Token.Type.SEMICOLON -> continue
|
||||
|
||||
@@ -407,7 +435,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 +634,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()
|
||||
@@ -667,19 +695,25 @@ class Compiler(
|
||||
"lambda must have either valid arguments declaration with '->' or no arguments"
|
||||
)
|
||||
|
||||
val paramNames = argsDeclaration?.params?.map { it.name } ?: emptyList()
|
||||
|
||||
label?.let { cc.labels.add(it) }
|
||||
val body = parseBlock(skipLeadingBrace = true)
|
||||
val body = inCodeContext(CodeContext.Function("<lambda>")) {
|
||||
withLocalNames(paramNames.toSet()) {
|
||||
parseBlock(skipLeadingBrace = true)
|
||||
}
|
||||
}
|
||||
label?.let { cc.labels.remove(it) }
|
||||
|
||||
return ValueFnRef { closureScope ->
|
||||
statement {
|
||||
statement(body.pos) { scope ->
|
||||
// and the source closure of the lambda which might have other thisObj.
|
||||
val context = this.applyClosure(closureScope)
|
||||
val context = scope.applyClosure(closureScope)
|
||||
// Execute lambda body in a closure-aware context. Blocks inside the lambda
|
||||
// will create child scopes as usual, so re-declarations inside loops work.
|
||||
if (argsDeclaration == null) {
|
||||
// no args: automatic var 'it'
|
||||
val l = args.list
|
||||
val l = scope.args.list
|
||||
val itValue: Obj = when (l.size) {
|
||||
// no args: it == void
|
||||
0 -> ObjVoid
|
||||
@@ -881,9 +915,17 @@ 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, Token.Type.ATLABEL -> {
|
||||
var isTransient = false
|
||||
if (t.type == Token.Type.ATLABEL) {
|
||||
if (t.value == "Transient") {
|
||||
isTransient = true
|
||||
t = cc.next()
|
||||
} else throw ScriptError(t.pos, "Unexpected label in argument list")
|
||||
}
|
||||
|
||||
Token.Type.ID -> {
|
||||
// visibility
|
||||
val visibility = if (isClassDeclaration && t.value == "private") {
|
||||
t = cc.next()
|
||||
@@ -911,12 +953,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,
|
||||
@@ -926,7 +969,8 @@ class Compiler(
|
||||
isEllipsis,
|
||||
defaultValue,
|
||||
access,
|
||||
visibility
|
||||
visibility,
|
||||
isTransient
|
||||
)
|
||||
|
||||
// important: valid argument list continues with ',' and ends with '->' or ')'
|
||||
@@ -1043,7 +1087,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)
|
||||
@@ -1320,7 +1369,7 @@ class Compiler(
|
||||
modifiers.add(currentToken.value)
|
||||
val next = cc.peekNextNonWhitespace()
|
||||
if (next.type == Token.Type.ID || next.type == Token.Type.OBJECT) {
|
||||
currentToken = cc.next()
|
||||
currentToken = nextNonWhitespace()
|
||||
} else {
|
||||
break
|
||||
}
|
||||
@@ -1348,7 +1397,9 @@ class Compiler(
|
||||
throw ScriptError(currentToken.pos, "abstract members cannot be private")
|
||||
|
||||
pendingDeclStart = firstId.pos
|
||||
pendingDeclDoc = consumePendingDoc()
|
||||
// pendingDeclDoc might be already set by an annotation
|
||||
if (pendingDeclDoc == null)
|
||||
pendingDeclDoc = consumePendingDoc()
|
||||
|
||||
val isMember = (codeContexts.lastOrNull() is CodeContext.ClassBody)
|
||||
|
||||
@@ -1476,7 +1527,14 @@ class Compiler(
|
||||
miniSink?.onInitDecl(MiniInitDecl(MiniRange(id.pos, range.end), id.pos))
|
||||
}
|
||||
val initStmt = statement(id.pos) { scp ->
|
||||
block.execute(scp)
|
||||
val cls = scp.thisObj.objClass
|
||||
val saved = scp.currentClassCtx
|
||||
scp.currentClassCtx = cls
|
||||
try {
|
||||
block.execute(scp)
|
||||
} finally {
|
||||
scp.currentClassCtx = saved
|
||||
}
|
||||
ObjVoid
|
||||
}
|
||||
statement {
|
||||
@@ -1721,7 +1779,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")
|
||||
@@ -1733,7 +1791,7 @@ class Compiler(
|
||||
errorObject.message,
|
||||
errorObject.extraData,
|
||||
errorObject.useStackTrace
|
||||
)
|
||||
).apply { getStackTrace() }
|
||||
throwScope.raiseError(errorObject)
|
||||
} else {
|
||||
val msg = errorObject.invokeInstanceMethod(sc, "message").toString(sc).value
|
||||
@@ -1864,29 +1922,35 @@ class Compiler(
|
||||
pendingDeclStart = null
|
||||
// so far only simplest enums:
|
||||
val names = mutableListOf<String>()
|
||||
val positions = mutableListOf<Pos>()
|
||||
// skip '{'
|
||||
cc.skipTokenOfType(Token.Type.LBRACE)
|
||||
|
||||
do {
|
||||
val t = cc.nextNonWhitespace()
|
||||
when (t.type) {
|
||||
Token.Type.ID -> {
|
||||
names += t.value
|
||||
val t1 = cc.nextNonWhitespace()
|
||||
when (t1.type) {
|
||||
Token.Type.COMMA ->
|
||||
continue
|
||||
if (cc.peekNextNonWhitespace().type != Token.Type.RBRACE) {
|
||||
do {
|
||||
val t = cc.nextNonWhitespace()
|
||||
when (t.type) {
|
||||
Token.Type.ID -> {
|
||||
names += t.value
|
||||
positions += t.pos
|
||||
val t1 = cc.nextNonWhitespace()
|
||||
when (t1.type) {
|
||||
Token.Type.COMMA ->
|
||||
continue
|
||||
|
||||
Token.Type.RBRACE -> break
|
||||
else -> {
|
||||
t1.raiseSyntax("unexpected token")
|
||||
Token.Type.RBRACE -> break
|
||||
else -> {
|
||||
t1.raiseSyntax("unexpected token")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
else -> t.raiseSyntax("expected enum entry name")
|
||||
}
|
||||
} while (true)
|
||||
else -> t.raiseSyntax("expected enum entry name")
|
||||
}
|
||||
} while (true)
|
||||
} else {
|
||||
cc.nextNonWhitespace()
|
||||
}
|
||||
|
||||
miniSink?.onEnumDecl(
|
||||
MiniEnumDecl(
|
||||
@@ -1895,7 +1959,8 @@ class Compiler(
|
||||
entries = names,
|
||||
doc = doc,
|
||||
nameStart = nameToken.pos,
|
||||
isExtern = isExtern
|
||||
isExtern = isExtern,
|
||||
entryPositions = positions
|
||||
)
|
||||
)
|
||||
|
||||
@@ -1995,6 +2060,7 @@ class Compiler(
|
||||
|
||||
val newClass = ObjInstanceClass(className, *parentClasses.toTypedArray())
|
||||
newClass.isAnonymous = nameToken == null
|
||||
newClass.constructorMeta = ArgsDeclaration(emptyList(), Token.Type.RPAREN)
|
||||
for (i in parentClasses.indices) {
|
||||
val argsList = baseSpecs[i].args
|
||||
// In object, we evaluate parent args once at creation time
|
||||
@@ -2174,6 +2240,7 @@ class Compiler(
|
||||
// but we should pass Pos.builtIn to skip validation for now if needed,
|
||||
// or p.pos to allow it.
|
||||
pos = Pos.builtIn,
|
||||
isTransient = p.isTransient,
|
||||
type = ObjRecord.Type.ConstructorField
|
||||
)
|
||||
}
|
||||
@@ -2192,20 +2259,6 @@ class Compiler(
|
||||
for (s in initScope)
|
||||
s.execute(classScope)
|
||||
}
|
||||
// Fallback: ensure any functions declared in class scope are also present as instance methods
|
||||
// (defensive in case some paths skipped cls.addFn during parsing/execution ordering)
|
||||
for ((k, rec) in classScope.objects) {
|
||||
val v = rec.value
|
||||
if (v is Statement) {
|
||||
if (newClass.members[k] == null) {
|
||||
newClass.addFn(k, isMutable = true, pos = rec.importedFrom?.pos ?: nameToken.pos) {
|
||||
(thisObj as? ObjInstance)?.let { i ->
|
||||
v.execute(ClosureScope(this, i.instanceScope))
|
||||
} ?: v.execute(thisObj.autoInstanceScope(this))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
newClass.checkAbstractSatisfaction(nameToken.pos)
|
||||
// Debug summary: list registered instance methods and class-scope functions for this class
|
||||
newClass
|
||||
@@ -2292,7 +2345,7 @@ class Compiler(
|
||||
} else if (sourceObj.isInstanceOf(ObjIterable)) {
|
||||
loopIterable(forContext, sourceObj, loopSO, body, elseStatement, label, canBreak)
|
||||
} else {
|
||||
val size = runCatching { sourceObj.invokeInstanceMethod(forContext, "size").toInt() }
|
||||
val size = runCatching { sourceObj.readField(forContext, "size").value.toInt() }
|
||||
.getOrElse {
|
||||
throw ScriptError(
|
||||
tOp.pos,
|
||||
@@ -2657,7 +2710,9 @@ class Compiler(
|
||||
isOverride: Boolean = false,
|
||||
isExtern: Boolean = false,
|
||||
isStatic: Boolean = false,
|
||||
isTransient: Boolean = isTransientFlag
|
||||
): Statement {
|
||||
isTransientFlag = false
|
||||
val actualExtern = isExtern || (codeContexts.lastOrNull() as? CodeContext.ClassBody)?.isExtern == true
|
||||
var t = cc.next()
|
||||
val start = t.pos
|
||||
@@ -2735,7 +2790,8 @@ class Compiler(
|
||||
doc = declDocLocal,
|
||||
nameStart = nameStartPos,
|
||||
receiver = receiverMini,
|
||||
isExtern = actualExtern
|
||||
isExtern = actualExtern,
|
||||
isStatic = isStatic
|
||||
)
|
||||
miniSink?.onFunDecl(node)
|
||||
pendingDeclDoc = null
|
||||
@@ -2826,16 +2882,16 @@ class Compiler(
|
||||
|
||||
val th = context.thisObj
|
||||
if (isStatic) {
|
||||
(th as ObjClass).createClassField(name, ObjUnset, false, visibility, null, start, type = ObjRecord.Type.Delegated).apply {
|
||||
(th as ObjClass).createClassField(name, ObjUnset, false, visibility, null, start, isTransient = isTransient, type = ObjRecord.Type.Delegated).apply {
|
||||
delegate = finalDelegate
|
||||
}
|
||||
context.addItem(name, false, ObjUnset, visibility, recordType = ObjRecord.Type.Delegated).apply {
|
||||
context.addItem(name, false, ObjUnset, visibility, recordType = ObjRecord.Type.Delegated, isTransient = isTransient).apply {
|
||||
delegate = finalDelegate
|
||||
}
|
||||
} else if (th is ObjClass) {
|
||||
val cls: ObjClass = th
|
||||
val storageName = "${cls.className}::$name"
|
||||
cls.createField(name, ObjUnset, false, visibility, null, start, declaringClass = cls, isAbstract = isAbstract, isClosed = isClosed, isOverride = isOverride, type = ObjRecord.Type.Delegated)
|
||||
cls.createField(name, ObjUnset, false, visibility, null, start, declaringClass = cls, isAbstract = isAbstract, isClosed = isClosed, isOverride = isOverride, isTransient = isTransient, type = ObjRecord.Type.Delegated)
|
||||
cls.instanceInitializers += statement(start) { scp ->
|
||||
val accessType2 = scp.resolveQualifiedIdentifier("DelegateAccess.Callable")
|
||||
val initValue2 = delegateExpression.execute(scp)
|
||||
@@ -2844,13 +2900,13 @@ class Compiler(
|
||||
} catch (e: Exception) {
|
||||
initValue2
|
||||
}
|
||||
scp.addItem(storageName, false, ObjUnset, visibility, null, recordType = ObjRecord.Type.Delegated, isAbstract = isAbstract, isClosed = isClosed, isOverride = isOverride).apply {
|
||||
scp.addItem(storageName, false, ObjUnset, visibility, null, recordType = ObjRecord.Type.Delegated, isAbstract = isAbstract, isClosed = isClosed, isOverride = isOverride, isTransient = isTransient).apply {
|
||||
delegate = finalDelegate2
|
||||
}
|
||||
ObjVoid
|
||||
}
|
||||
} else {
|
||||
context.addItem(name, false, ObjUnset, visibility, recordType = ObjRecord.Type.Delegated).apply {
|
||||
context.addItem(name, false, ObjUnset, visibility, recordType = ObjRecord.Type.Delegated, isTransient = isTransient).apply {
|
||||
delegate = finalDelegate
|
||||
}
|
||||
}
|
||||
@@ -2942,10 +2998,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)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2978,8 +3035,10 @@ class Compiler(
|
||||
isClosed: Boolean = false,
|
||||
isOverride: Boolean = false,
|
||||
isStatic: Boolean = false,
|
||||
isExtern: Boolean = false
|
||||
isExtern: Boolean = false,
|
||||
isTransient: Boolean = isTransientFlag
|
||||
): Statement {
|
||||
isTransientFlag = false
|
||||
val actualExtern = isExtern || (codeContexts.lastOrNull() as? CodeContext.ClassBody)?.isExtern == true
|
||||
val nextToken = cc.next()
|
||||
val start = nextToken.pos
|
||||
@@ -3003,7 +3062,8 @@ class Compiler(
|
||||
initRange = null,
|
||||
doc = pendingDeclDoc,
|
||||
nameStart = namePos,
|
||||
isExtern = actualExtern
|
||||
isExtern = actualExtern,
|
||||
isStatic = false
|
||||
)
|
||||
miniSink?.onValDecl(node)
|
||||
}
|
||||
@@ -3022,7 +3082,7 @@ class Compiler(
|
||||
return statement(start) { context ->
|
||||
val value = initialExpression.execute(context)
|
||||
for (name in names) {
|
||||
context.addItem(name, true, ObjVoid, visibility)
|
||||
context.addItem(name, true, ObjVoid, visibility, isTransient = isTransient)
|
||||
}
|
||||
pattern.setAt(start, context, value)
|
||||
if (!isMutable) {
|
||||
@@ -3079,31 +3139,88 @@ class Compiler(
|
||||
val mark = cc.savePos()
|
||||
cc.restorePos(markBeforeEq)
|
||||
cc.skipWsTokens()
|
||||
val next = cc.peekNextNonWhitespace()
|
||||
if (next.isId("get") || next.isId("set") || next.isId("private") || next.isId("protected")) {
|
||||
|
||||
// Heuristic: if we see 'get(' or 'set(' or 'private set(' or 'protected set(',
|
||||
// look ahead for a body.
|
||||
fun hasAccessorWithBody(): Boolean {
|
||||
val t = cc.peekNextNonWhitespace()
|
||||
if (t.isId("get") || t.isId("set")) {
|
||||
val saved = cc.savePos()
|
||||
cc.next() // consume get/set
|
||||
val nextToken = cc.peekNextNonWhitespace()
|
||||
if (nextToken.type == Token.Type.LPAREN) {
|
||||
cc.next() // consume (
|
||||
var depth = 1
|
||||
while (cc.hasNext() && depth > 0) {
|
||||
val tt = cc.next()
|
||||
if (tt.type == Token.Type.LPAREN) depth++
|
||||
else if (tt.type == Token.Type.RPAREN) depth--
|
||||
}
|
||||
val next = cc.peekNextNonWhitespace()
|
||||
if (next.type == Token.Type.LBRACE || next.type == Token.Type.ASSIGN) {
|
||||
cc.restorePos(saved)
|
||||
return true
|
||||
}
|
||||
} else if (nextToken.type == Token.Type.LBRACE || nextToken.type == Token.Type.ASSIGN) {
|
||||
cc.restorePos(saved)
|
||||
return true
|
||||
}
|
||||
cc.restorePos(saved)
|
||||
} else if (t.isId("private") || t.isId("protected")) {
|
||||
val saved = cc.savePos()
|
||||
cc.next() // consume modifier
|
||||
if (cc.skipWsTokens().isId("set")) {
|
||||
cc.next() // consume set
|
||||
val nextToken = cc.peekNextNonWhitespace()
|
||||
if (nextToken.type == Token.Type.LPAREN) {
|
||||
cc.next() // consume (
|
||||
var depth = 1
|
||||
while (cc.hasNext() && depth > 0) {
|
||||
val tt = cc.next()
|
||||
if (tt.type == Token.Type.LPAREN) depth++
|
||||
else if (tt.type == Token.Type.RPAREN) depth--
|
||||
}
|
||||
val next = cc.peekNextNonWhitespace()
|
||||
if (next.type == Token.Type.LBRACE || next.type == Token.Type.ASSIGN) {
|
||||
cc.restorePos(saved)
|
||||
return true
|
||||
}
|
||||
} else if (nextToken.type == Token.Type.LBRACE || nextToken.type == Token.Type.ASSIGN) {
|
||||
cc.restorePos(saved)
|
||||
return true
|
||||
}
|
||||
}
|
||||
cc.restorePos(saved)
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
if (hasAccessorWithBody()) {
|
||||
isProperty = true
|
||||
cc.restorePos(markBeforeEq)
|
||||
cc.skipWsTokens()
|
||||
// Do not consume eqToken if it's an accessor keyword
|
||||
} else {
|
||||
cc.restorePos(mark)
|
||||
}
|
||||
}
|
||||
|
||||
val effectiveEqToken = if (isProperty) null else eqToken
|
||||
|
||||
// Register the local name at compile time so that subsequent identifiers can be emitted as fast locals
|
||||
if (!isStatic) declareLocalName(name)
|
||||
|
||||
val isDelegate = if (isAbstract || actualExtern) {
|
||||
if (!isProperty && (eqToken.type == Token.Type.ASSIGN || eqToken.type == Token.Type.BY))
|
||||
throw ScriptError(eqToken.pos, "${if (isAbstract) "abstract" else "extern"} variable $name cannot have an initializer or delegate")
|
||||
if (!isProperty && (effectiveEqToken?.type == Token.Type.ASSIGN || effectiveEqToken?.type == Token.Type.BY))
|
||||
throw ScriptError(effectiveEqToken.pos, "${if (isAbstract) "abstract" else "extern"} variable $name cannot have an initializer or delegate")
|
||||
// Abstract or extern variables don't have initializers
|
||||
cc.restorePos(markBeforeEq)
|
||||
cc.skipWsTokens()
|
||||
setNull = true
|
||||
false
|
||||
} else if (!isProperty && eqToken.type == Token.Type.BY) {
|
||||
} else if (!isProperty && effectiveEqToken?.type == Token.Type.BY) {
|
||||
true
|
||||
} else {
|
||||
if (!isProperty && eqToken.type != Token.Type.ASSIGN) {
|
||||
if (!isProperty && effectiveEqToken?.type != Token.Type.ASSIGN) {
|
||||
if (!isMutable && (declaringClassNameCaptured == null) && (extTypeName == null))
|
||||
throw ScriptError(start, "val must be initialized")
|
||||
else if (!isMutable && declaringClassNameCaptured != null && extTypeName == null) {
|
||||
@@ -3123,12 +3240,12 @@ class Compiler(
|
||||
|
||||
val initialExpression = if (setNull || isProperty) null
|
||||
else parseStatement(true)
|
||||
?: throw ScriptError(eqToken.pos, "Expected initializer expression")
|
||||
?: throw ScriptError(effectiveEqToken!!.pos, "Expected initializer expression")
|
||||
|
||||
// Emit MiniValDecl for this declaration (before execution wiring), attach doc if any
|
||||
run {
|
||||
val declRange = MiniRange(pendingDeclStart ?: start, cc.currentPos())
|
||||
val initR = if (setNull || isProperty) null else MiniRange(eqToken.pos, cc.currentPos())
|
||||
val initR = if (setNull || isProperty) null else MiniRange(effectiveEqToken!!.pos, cc.currentPos())
|
||||
val node = MiniValDecl(
|
||||
range = declRange,
|
||||
name = name,
|
||||
@@ -3138,7 +3255,8 @@ class Compiler(
|
||||
doc = pendingDeclDoc,
|
||||
nameStart = nameStartPos,
|
||||
receiver = receiverMini,
|
||||
isExtern = actualExtern
|
||||
isExtern = actualExtern,
|
||||
isStatic = isStatic
|
||||
)
|
||||
miniSink?.onValDecl(node)
|
||||
pendingDeclDoc = null
|
||||
@@ -3166,17 +3284,18 @@ class Compiler(
|
||||
visibility,
|
||||
null,
|
||||
start,
|
||||
isTransient = isTransient,
|
||||
type = ObjRecord.Type.Delegated
|
||||
).apply {
|
||||
delegate = finalDelegate
|
||||
}
|
||||
// Also expose in current init scope
|
||||
addItem(name, isMutable, ObjUnset, visibility, null, ObjRecord.Type.Delegated).apply {
|
||||
addItem(name, isMutable, ObjUnset, visibility, null, ObjRecord.Type.Delegated, isTransient = isTransient).apply {
|
||||
delegate = finalDelegate
|
||||
}
|
||||
} else {
|
||||
(thisObj as ObjClass).createClassField(name, initValue, isMutable, visibility, null, start)
|
||||
addItem(name, isMutable, initValue, visibility, null, ObjRecord.Type.Field)
|
||||
(thisObj as ObjClass).createClassField(name, initValue, isMutable, visibility, null, start, isTransient = isTransient)
|
||||
addItem(name, isMutable, initValue, visibility, null, ObjRecord.Type.Field, isTransient = isTransient)
|
||||
}
|
||||
ObjVoid
|
||||
}
|
||||
@@ -3193,17 +3312,24 @@ class Compiler(
|
||||
if (t.isId("get")) {
|
||||
val getStart = cc.currentPos()
|
||||
cc.next() // consume 'get'
|
||||
cc.requireToken(Token.Type.LPAREN)
|
||||
cc.requireToken(Token.Type.RPAREN)
|
||||
if (cc.peekNextNonWhitespace().type == Token.Type.LPAREN) {
|
||||
cc.next() // consume (
|
||||
cc.requireToken(Token.Type.RPAREN)
|
||||
}
|
||||
miniSink?.onEnterFunction(null)
|
||||
getter = if (cc.peekNextNonWhitespace().type == Token.Type.LBRACE) {
|
||||
cc.skipWsTokens()
|
||||
parseBlock()
|
||||
inCodeContext(CodeContext.Function("<getter>")) {
|
||||
parseBlock()
|
||||
}
|
||||
} else if (cc.peekNextNonWhitespace().type == Token.Type.ASSIGN) {
|
||||
cc.skipWsTokens()
|
||||
cc.next() // consume '='
|
||||
val expr = parseExpression() ?: throw ScriptError(cc.current().pos, "Expected getter expression")
|
||||
expr
|
||||
inCodeContext(CodeContext.Function("<getter>")) {
|
||||
val expr = parseExpression()
|
||||
?: throw ScriptError(cc.current().pos, "Expected getter expression")
|
||||
expr
|
||||
}
|
||||
} else {
|
||||
throw ScriptError(cc.current().pos, "Expected { or = after get()")
|
||||
}
|
||||
@@ -3211,26 +3337,34 @@ class Compiler(
|
||||
} else if (t.isId("set")) {
|
||||
val setStart = cc.currentPos()
|
||||
cc.next() // consume 'set'
|
||||
cc.requireToken(Token.Type.LPAREN)
|
||||
val setArg = cc.requireToken(Token.Type.ID, "Expected setter argument name")
|
||||
cc.requireToken(Token.Type.RPAREN)
|
||||
var setArgName = "it"
|
||||
if (cc.peekNextNonWhitespace().type == Token.Type.LPAREN) {
|
||||
cc.next() // consume (
|
||||
setArgName = cc.requireToken(Token.Type.ID, "Expected setter argument name").value
|
||||
cc.requireToken(Token.Type.RPAREN)
|
||||
}
|
||||
miniSink?.onEnterFunction(null)
|
||||
setter = if (cc.peekNextNonWhitespace().type == Token.Type.LBRACE) {
|
||||
cc.skipWsTokens()
|
||||
val body = parseBlock()
|
||||
val body = inCodeContext(CodeContext.Function("<setter>")) {
|
||||
parseBlock()
|
||||
}
|
||||
statement(body.pos) { scope ->
|
||||
val value = scope.args.list.firstOrNull() ?: ObjNull
|
||||
scope.addItem(setArg.value, true, value, recordType = ObjRecord.Type.Argument)
|
||||
scope.addItem(setArgName, true, value, recordType = ObjRecord.Type.Argument)
|
||||
body.execute(scope)
|
||||
}
|
||||
} else if (cc.peekNextNonWhitespace().type == Token.Type.ASSIGN) {
|
||||
cc.skipWsTokens()
|
||||
cc.next() // consume '='
|
||||
val expr = parseExpression() ?: throw ScriptError(cc.current().pos, "Expected setter expression")
|
||||
val expr = inCodeContext(CodeContext.Function("<setter>")) {
|
||||
parseExpression()
|
||||
?: throw ScriptError(cc.current().pos, "Expected setter expression")
|
||||
}
|
||||
val st = expr
|
||||
statement(st.pos) { scope ->
|
||||
val value = scope.args.list.firstOrNull() ?: ObjNull
|
||||
scope.addItem(setArg.value, true, value, recordType = ObjRecord.Type.Argument)
|
||||
scope.addItem(setArgName, true, value, recordType = ObjRecord.Type.Argument)
|
||||
st.execute(scope)
|
||||
}
|
||||
} else {
|
||||
@@ -3249,9 +3383,11 @@ class Compiler(
|
||||
val setArg = cc.requireToken(Token.Type.ID, "Expected setter argument name")
|
||||
cc.requireToken(Token.Type.RPAREN)
|
||||
miniSink?.onEnterFunction(null)
|
||||
setter = if (cc.peekNextNonWhitespace().type == Token.Type.LBRACE) {
|
||||
val finalSetter = if (cc.peekNextNonWhitespace().type == Token.Type.LBRACE) {
|
||||
cc.skipWsTokens()
|
||||
val body = parseBlock()
|
||||
val body = inCodeContext(CodeContext.Function("<setter>")) {
|
||||
parseBlock()
|
||||
}
|
||||
statement(body.pos) { scope ->
|
||||
val value = scope.args.list.firstOrNull() ?: ObjNull
|
||||
scope.addItem(setArg.value, true, value, recordType = ObjRecord.Type.Argument)
|
||||
@@ -3260,11 +3396,12 @@ class Compiler(
|
||||
} else if (cc.peekNextNonWhitespace().type == Token.Type.ASSIGN) {
|
||||
cc.skipWsTokens()
|
||||
cc.next() // consume '='
|
||||
val expr = parseExpression() ?: throw ScriptError(
|
||||
cc.current().pos,
|
||||
"Expected setter expression"
|
||||
)
|
||||
val st = expr
|
||||
val st = inCodeContext(CodeContext.Function("<setter>")) {
|
||||
parseExpression() ?: throw ScriptError(
|
||||
cc.current().pos,
|
||||
"Expected setter expression"
|
||||
)
|
||||
}
|
||||
statement(st.pos) { scope ->
|
||||
val value = scope.args.list.firstOrNull() ?: ObjNull
|
||||
scope.addItem(setArg.value, true, value, recordType = ObjRecord.Type.Argument)
|
||||
@@ -3273,7 +3410,10 @@ class Compiler(
|
||||
} else {
|
||||
throw ScriptError(cc.current().pos, "Expected { or = after set(...)")
|
||||
}
|
||||
setter = finalSetter
|
||||
miniSink?.onExitFunction(cc.currentPos())
|
||||
} else {
|
||||
// private set without body: setter remains null, visibility is restricted
|
||||
}
|
||||
} else {
|
||||
cc.restorePos(mark)
|
||||
@@ -3317,6 +3457,7 @@ class Compiler(
|
||||
// In true class bodies (not inside a function), store fields under a class-qualified key to support MI collisions
|
||||
// Do NOT infer declaring class from runtime thisObj here; only the compile-time captured
|
||||
// ClassBody qualifies for class-field storage. Otherwise, this is a plain local.
|
||||
isProperty = getter != null || setter != null
|
||||
val declaringClassName = declaringClassNameCaptured
|
||||
if (declaringClassName == null) {
|
||||
if (context.containsLocal(name))
|
||||
@@ -3340,6 +3481,7 @@ class Compiler(
|
||||
visibility,
|
||||
setterVisibility,
|
||||
start,
|
||||
isTransient = isTransient,
|
||||
type = ObjRecord.Type.Delegated,
|
||||
isAbstract = isAbstract,
|
||||
isClosed = isClosed,
|
||||
@@ -3359,7 +3501,8 @@ class Compiler(
|
||||
recordType = ObjRecord.Type.Delegated,
|
||||
isAbstract = isAbstract,
|
||||
isClosed = isClosed,
|
||||
isOverride = isOverride
|
||||
isOverride = isOverride,
|
||||
isTransient = isTransient
|
||||
).apply {
|
||||
delegate = finalDelegate
|
||||
}
|
||||
@@ -3380,7 +3523,8 @@ class Compiler(
|
||||
recordType = ObjRecord.Type.Delegated,
|
||||
isAbstract = isAbstract,
|
||||
isClosed = isClosed,
|
||||
isOverride = isOverride
|
||||
isOverride = isOverride,
|
||||
isTransient = isTransient
|
||||
)
|
||||
rec.delegate = finalDelegate
|
||||
return@statement finalDelegate
|
||||
@@ -3399,7 +3543,8 @@ class Compiler(
|
||||
recordType = ObjRecord.Type.Delegated,
|
||||
isAbstract = isAbstract,
|
||||
isClosed = isClosed,
|
||||
isOverride = isOverride
|
||||
isOverride = isOverride,
|
||||
isTransient = isTransient
|
||||
)
|
||||
rec.delegate = finalDelegate
|
||||
return@statement finalDelegate
|
||||
@@ -3422,7 +3567,8 @@ class Compiler(
|
||||
isAbstract = isAbstract,
|
||||
isClosed = isClosed,
|
||||
isOverride = isOverride,
|
||||
pos = start
|
||||
pos = start,
|
||||
prop = prop
|
||||
)
|
||||
} else {
|
||||
cls.createField(
|
||||
@@ -3434,6 +3580,7 @@ class Compiler(
|
||||
isAbstract = isAbstract,
|
||||
isClosed = isClosed,
|
||||
isOverride = isOverride,
|
||||
isTransient = isTransient,
|
||||
type = ObjRecord.Type.Field
|
||||
)
|
||||
}
|
||||
@@ -3463,7 +3610,8 @@ class Compiler(
|
||||
recordType = ObjRecord.Type.Property,
|
||||
isAbstract = isAbstract,
|
||||
isClosed = isClosed,
|
||||
isOverride = isOverride
|
||||
isOverride = isOverride,
|
||||
isTransient = isTransient
|
||||
)
|
||||
prop
|
||||
}
|
||||
@@ -3486,6 +3634,7 @@ class Compiler(
|
||||
isClosed = isClosed,
|
||||
isOverride = isOverride,
|
||||
pos = start,
|
||||
isTransient = isTransient,
|
||||
type = ObjRecord.Type.Field
|
||||
)
|
||||
|
||||
@@ -3501,7 +3650,8 @@ class Compiler(
|
||||
recordType = ObjRecord.Type.Field,
|
||||
isAbstract = isAbstract,
|
||||
isClosed = isClosed,
|
||||
isOverride = isOverride
|
||||
isOverride = isOverride,
|
||||
isTransient = isTransient
|
||||
)
|
||||
ObjVoid
|
||||
}
|
||||
@@ -3518,14 +3668,15 @@ class Compiler(
|
||||
recordType = ObjRecord.Type.Field,
|
||||
isAbstract = isAbstract,
|
||||
isClosed = isClosed,
|
||||
isOverride = isOverride
|
||||
isOverride = isOverride,
|
||||
isTransient = isTransient
|
||||
)
|
||||
initValue
|
||||
}
|
||||
} else {
|
||||
// Not in class body: regular local/var declaration
|
||||
val initValue = initialExpression?.execute(context)?.byValueCopy() ?: ObjNull
|
||||
context.addItem(name, isMutable, initValue, visibility, recordType = ObjRecord.Type.Field)
|
||||
context.addItem(name, isMutable, initValue, visibility, recordType = ObjRecord.Type.Other, isTransient = isTransient)
|
||||
initValue
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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) {
|
||||
@@ -106,27 +105,37 @@ open class Scope(
|
||||
* intertwined closure frames. They traverse the plain parent chain and consult only locals
|
||||
* and bindings of each frame. Instance/class member fallback must be decided by the caller.
|
||||
*/
|
||||
private fun tryGetLocalRecord(s: Scope, name: String, caller: net.sergeych.lyng.obj.ObjClass?): ObjRecord? {
|
||||
internal fun tryGetLocalRecord(s: Scope, name: String, caller: net.sergeych.lyng.obj.ObjClass?): ObjRecord? {
|
||||
caller?.let { ctx ->
|
||||
s.objects[ctx.mangledName(name)]?.let { rec ->
|
||||
if (rec.visibility == Visibility.Private) return rec
|
||||
}
|
||||
}
|
||||
s.objects[name]?.let { rec ->
|
||||
if (rec.declaringClass == null || canAccessMember(rec.visibility, rec.declaringClass, caller)) return rec
|
||||
if (rec.declaringClass == null || canAccessMember(rec.visibility, rec.declaringClass, caller, name)) return rec
|
||||
}
|
||||
caller?.let { ctx ->
|
||||
s.localBindings[ctx.mangledName(name)]?.let { rec ->
|
||||
if (rec.visibility == Visibility.Private) return rec
|
||||
}
|
||||
}
|
||||
s.localBindings[name]?.let { rec ->
|
||||
if (rec.declaringClass == null || canAccessMember(rec.visibility, rec.declaringClass, caller)) return rec
|
||||
if (rec.declaringClass == null || canAccessMember(rec.visibility, rec.declaringClass, caller, name)) return rec
|
||||
}
|
||||
s.getSlotIndexOf(name)?.let { idx ->
|
||||
val rec = s.getSlotRecord(idx)
|
||||
if (rec.declaringClass == null || canAccessMember(rec.visibility, rec.declaringClass, caller)) return rec
|
||||
if (rec.declaringClass == null || canAccessMember(rec.visibility, rec.declaringClass, caller, name)) return rec
|
||||
}
|
||||
return null
|
||||
}
|
||||
|
||||
internal fun chainLookupIgnoreClosure(name: String, followClosure: Boolean = false): ObjRecord? {
|
||||
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)
|
||||
while (s != null) {
|
||||
if (!visited.add(s.frameId)) return null
|
||||
tryGetLocalRecord(s, name, currentClassCtx)?.let { return it }
|
||||
// use hop counter to detect unexpected structural cycles in the parent chain
|
||||
var hops = 0
|
||||
val effectiveCaller = caller ?: currentClassCtx
|
||||
while (s != null && hops++ < 1024) {
|
||||
tryGetLocalRecord(s, name, effectiveCaller)?.let { return it }
|
||||
s = if (followClosure && s is ClosureScope) s.closureScope else s.parent
|
||||
}
|
||||
return null
|
||||
@@ -144,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
|
||||
}
|
||||
@@ -155,7 +163,7 @@ open class Scope(
|
||||
this.extensions[cls]?.get(name)?.let { return it }
|
||||
}
|
||||
return thisObj.objClass.getInstanceMemberOrNull(name)?.let { rec ->
|
||||
if (canAccessMember(rec.visibility, rec.declaringClass, currentClassCtx)) {
|
||||
if (canAccessMember(rec.visibility, rec.declaringClass, currentClassCtx, name)) {
|
||||
if (rec.type == ObjRecord.Type.Field || rec.type == ObjRecord.Type.Property || rec.isAbstract) null
|
||||
else rec
|
||||
} else null
|
||||
@@ -171,15 +179,14 @@ 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 }
|
||||
}
|
||||
s.thisObj.objClass.getInstanceMemberOrNull(name)?.let { rec ->
|
||||
if (canAccessMember(rec.visibility, rec.declaringClass, caller)) {
|
||||
if (canAccessMember(rec.visibility, rec.declaringClass, caller, name)) {
|
||||
if (rec.type == ObjRecord.Type.Field || rec.type == ObjRecord.Type.Property || rec.isAbstract) {
|
||||
// ignore fields, properties and abstracts here, they will be handled by the caller via readField
|
||||
} else return rec
|
||||
@@ -330,29 +337,43 @@ open class Scope(
|
||||
|
||||
internal val objects = mutableMapOf<String, ObjRecord>()
|
||||
|
||||
open operator fun get(name: String): ObjRecord? =
|
||||
if (name == "this") thisObj.asReadonly
|
||||
else {
|
||||
// Prefer direct locals/bindings declared in this frame
|
||||
(objects[name]?.let { rec ->
|
||||
if (rec.declaringClass == null || canAccessMember(rec.visibility, rec.declaringClass, currentClassCtx)) rec else null
|
||||
}
|
||||
// Then, check known local bindings in this frame (helps after suspension)
|
||||
?: localBindings[name]?.let { rec ->
|
||||
if (rec.declaringClass == null || canAccessMember(rec.visibility, rec.declaringClass, currentClassCtx)) rec else null
|
||||
}
|
||||
// Walk up ancestry
|
||||
?: parent?.get(name)
|
||||
// Finally, fallback to class members on thisObj
|
||||
?: thisObj.objClass.getInstanceMemberOrNull(name)?.let { rec ->
|
||||
if (canAccessMember(rec.visibility, rec.declaringClass, currentClassCtx)) {
|
||||
if (rec.type == ObjRecord.Type.Field || rec.type == ObjRecord.Type.Property || rec.isAbstract) null
|
||||
else rec
|
||||
} else null
|
||||
}
|
||||
)
|
||||
open operator fun get(name: String): ObjRecord? {
|
||||
if (name == "this") return thisObj.asReadonly
|
||||
|
||||
// 1. Prefer direct locals/bindings declared in this frame
|
||||
tryGetLocalRecord(this, name, currentClassCtx)?.let { return it }
|
||||
|
||||
val p = parent
|
||||
|
||||
// 2. If we share thisObj with parent, delegate to parent to maintain
|
||||
// "locals shadow members" priority across the this-context.
|
||||
if (p != null && p.thisObj === thisObj) {
|
||||
return p.get(name)
|
||||
}
|
||||
|
||||
// 3. Otherwise, we are the "primary" scope for this thisObj (or have no parent),
|
||||
// so check members of thisObj before walking up to a different this-context.
|
||||
val receiver = thisObj
|
||||
val effectiveClass = receiver as? ObjClass ?: receiver.objClass
|
||||
for (cls in effectiveClass.mro) {
|
||||
val rec = cls.members[name] ?: cls.classScope?.objects?.get(name)
|
||||
if (rec != null && !rec.isAbstract) {
|
||||
if (canAccessMember(rec.visibility, rec.declaringClass ?: cls, currentClassCtx, name)) {
|
||||
return rec.copy(receiver = receiver)
|
||||
}
|
||||
}
|
||||
}
|
||||
// Finally, root object fallback
|
||||
Obj.rootObjectType.members[name]?.let { rec ->
|
||||
if (canAccessMember(rec.visibility, rec.declaringClass, currentClassCtx, name)) {
|
||||
return rec.copy(receiver = receiver)
|
||||
}
|
||||
}
|
||||
|
||||
// 4. Finally, walk up ancestry to a scope with a different thisObj context
|
||||
return p?.get(name)
|
||||
}
|
||||
|
||||
// Slot fast-path API
|
||||
fun getSlotRecord(index: Int): ObjRecord = slots[index]
|
||||
fun setSlotValue(index: Int, newValue: Obj) {
|
||||
@@ -371,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.
|
||||
@@ -380,6 +415,7 @@ open class Scope(
|
||||
// that could interact badly with the new parent and produce a cycle.
|
||||
this.parent = null
|
||||
this.skipScopeCreation = false
|
||||
this.currentClassCtx = parent?.currentClassCtx
|
||||
// fresh identity for PIC caches
|
||||
this.frameId = nextFrameId()
|
||||
// clear locals and slot maps
|
||||
@@ -480,7 +516,8 @@ open class Scope(
|
||||
declaringClass: net.sergeych.lyng.obj.ObjClass? = currentClassCtx,
|
||||
isAbstract: Boolean = false,
|
||||
isClosed: Boolean = false,
|
||||
isOverride: Boolean = false
|
||||
isOverride: Boolean = false,
|
||||
isTransient: Boolean = false
|
||||
): ObjRecord {
|
||||
val rec = ObjRecord(
|
||||
value, isMutable, visibility, writeVisibility,
|
||||
@@ -488,7 +525,8 @@ open class Scope(
|
||||
type = recordType,
|
||||
isAbstract = isAbstract,
|
||||
isClosed = isClosed,
|
||||
isOverride = isOverride
|
||||
isOverride = isOverride,
|
||||
isTransient = isTransient
|
||||
)
|
||||
objects[name] = rec
|
||||
// Index this binding within the current frame to help resolve locals across suspension
|
||||
@@ -507,11 +545,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
|
||||
}
|
||||
@@ -628,46 +670,34 @@ open class Scope(
|
||||
}
|
||||
|
||||
suspend fun resolve(rec: ObjRecord, name: String): Obj {
|
||||
if (rec.type == ObjRecord.Type.Delegated) {
|
||||
val del = rec.delegate ?: run {
|
||||
if (thisObj is ObjInstance) {
|
||||
val res = (thisObj as ObjInstance).resolveRecord(this, rec, name, rec.declaringClass).value
|
||||
rec.value = res
|
||||
return res
|
||||
}
|
||||
raiseError("Internal error: delegated property $name has no delegate")
|
||||
}
|
||||
val th = if (thisObj === ObjVoid) ObjNull else thisObj
|
||||
val res = del.invokeInstanceMethod(this, "getValue", Arguments(th, ObjString(name)), onNotFoundResult = {
|
||||
// If getValue not found, return a wrapper that calls invoke
|
||||
object : Statement() {
|
||||
override val pos: Pos = Pos.builtIn
|
||||
override suspend fun execute(scope: Scope): Obj {
|
||||
val th2 = if (scope.thisObj === ObjVoid) ObjNull else scope.thisObj
|
||||
val allArgs = (listOf(th2, ObjString(name)) + scope.args.list).toTypedArray()
|
||||
return del.invokeInstanceMethod(scope, "invoke", Arguments(*allArgs))
|
||||
}
|
||||
}
|
||||
})
|
||||
rec.value = res
|
||||
return res
|
||||
}
|
||||
return rec.value
|
||||
val receiver = rec.receiver ?: thisObj
|
||||
return receiver.resolveRecord(this, rec, name, rec.declaringClass).value
|
||||
}
|
||||
|
||||
suspend fun assign(rec: ObjRecord, name: String, newValue: Obj) {
|
||||
if (rec.type == ObjRecord.Type.Delegated) {
|
||||
val receiver = rec.receiver ?: thisObj
|
||||
val del = rec.delegate ?: run {
|
||||
if (thisObj is ObjInstance) {
|
||||
(thisObj as ObjInstance).writeField(this, name, newValue)
|
||||
if (receiver is ObjInstance) {
|
||||
(receiver as ObjInstance).writeField(this, name, newValue)
|
||||
return
|
||||
}
|
||||
raiseError("Internal error: delegated property $name has no delegate")
|
||||
}
|
||||
val th = if (thisObj === ObjVoid) ObjNull else thisObj
|
||||
val th = if (receiver === ObjVoid) ObjNull else receiver
|
||||
del.invokeInstanceMethod(this, "setValue", Arguments(th, ObjString(name), newValue))
|
||||
return
|
||||
}
|
||||
if (rec.value is ObjProperty) {
|
||||
(rec.value as ObjProperty).callSetter(this, rec.receiver ?: thisObj, newValue, rec.declaringClass)
|
||||
return
|
||||
}
|
||||
// If it's a member (explicitly tracked by receiver or declaringClass), use writeField.
|
||||
// Important: locals have receiver == null and declaringClass == null (enforced in addItem).
|
||||
if (rec.receiver != null || (rec.declaringClass != null && (rec.type == ObjRecord.Type.Field || rec.type == ObjRecord.Type.Property))) {
|
||||
(rec.receiver ?: thisObj).writeField(this, name, newValue)
|
||||
return
|
||||
}
|
||||
if (!rec.isMutable && rec.value !== ObjUnset) raiseIllegalAssignment("can't reassign val $name")
|
||||
rec.value = newValue
|
||||
}
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -20,10 +20,7 @@ package net.sergeych.lyng
|
||||
import kotlinx.coroutines.delay
|
||||
import kotlinx.coroutines.yield
|
||||
import net.sergeych.lyng.Script.Companion.defaultImportManager
|
||||
import net.sergeych.lyng.miniast.addConstDoc
|
||||
import net.sergeych.lyng.miniast.addFnDoc
|
||||
import net.sergeych.lyng.miniast.addVoidFnDoc
|
||||
import net.sergeych.lyng.miniast.type
|
||||
import net.sergeych.lyng.miniast.*
|
||||
import net.sergeych.lyng.obj.*
|
||||
import net.sergeych.lyng.pacman.ImportManager
|
||||
import net.sergeych.lyng.stdlib_included.rootLyng
|
||||
@@ -162,6 +159,42 @@ class Script(
|
||||
if (x is ObjInt) ObjInt(x.value.absoluteValue) else ObjReal(x.toDouble().absoluteValue)
|
||||
}
|
||||
|
||||
addFnDoc(
|
||||
"clamp",
|
||||
doc = "Clamps the value within the specified range. If the value is outside the range, it is set to the nearest boundary. Respects inclusive/exclusive range ends.",
|
||||
params = listOf(ParamDoc("value"), ParamDoc("range")),
|
||||
moduleName = "lyng.stdlib"
|
||||
) {
|
||||
val value = requiredArg<Obj>(0)
|
||||
val range = requiredArg<ObjRange>(1)
|
||||
|
||||
var result = value
|
||||
if (range.start != null && !range.start.isNull) {
|
||||
if (result.compareTo(this, range.start) < 0) {
|
||||
result = range.start
|
||||
}
|
||||
}
|
||||
if (range.end != null && !range.end.isNull) {
|
||||
val cmp = range.end.compareTo(this, result)
|
||||
if (range.isEndInclusive) {
|
||||
if (cmp < 0) result = range.end
|
||||
} else {
|
||||
if (cmp <= 0) {
|
||||
if (range.end is ObjInt) {
|
||||
result = ObjInt.of(range.end.value - 1)
|
||||
} else if (range.end is ObjChar) {
|
||||
result = ObjChar((range.end.value.code - 1).toChar())
|
||||
} else {
|
||||
// For types where we can't easily find "previous" value (like Real),
|
||||
// we just return the exclusive boundary as a fallback.
|
||||
result = range.end
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
addVoidFn("assert") {
|
||||
val cond = requiredArg<ObjBool>(0)
|
||||
val message = if (args.size > 1)
|
||||
@@ -293,10 +326,14 @@ class Script(
|
||||
ObjVoid
|
||||
}
|
||||
|
||||
// Delay in milliseconds (plain numeric). For time-aware variants use lyng.time.Duration API.
|
||||
addVoidFn("delay") {
|
||||
val ms = (this.args.firstAndOnly().toDouble()).roundToLong()
|
||||
delay(ms)
|
||||
val a = args.firstAndOnly()
|
||||
when (a) {
|
||||
is ObjInt -> delay(a.value)
|
||||
is ObjReal -> delay((a.value * 1000).roundToLong())
|
||||
is ObjDuration -> delay(a.duration)
|
||||
else -> raiseIllegalArgument("Expected Int, Real or Duration, got ${a.inspect(this)}")
|
||||
}
|
||||
}
|
||||
|
||||
addConst("Object", rootObjectType)
|
||||
@@ -395,6 +432,12 @@ class Script(
|
||||
doc = "Point in time (epoch-based).",
|
||||
type = type("lyng.Class")
|
||||
)
|
||||
it.addConstDoc(
|
||||
name = "DateTime",
|
||||
value = ObjDateTime.type,
|
||||
doc = "Point in time in a specific time zone.",
|
||||
type = type("lyng.Class")
|
||||
)
|
||||
it.addConstDoc(
|
||||
name = "Duration",
|
||||
value = ObjDuration.type,
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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.
|
||||
@@ -25,7 +25,12 @@ enum class Visibility {
|
||||
}
|
||||
|
||||
/** MI-aware visibility check: whether [caller] can access a member declared in [decl] with [visibility]. */
|
||||
fun canAccessMember(visibility: Visibility, decl: net.sergeych.lyng.obj.ObjClass?, caller: net.sergeych.lyng.obj.ObjClass?): Boolean {
|
||||
fun canAccessMember(
|
||||
visibility: Visibility,
|
||||
decl: net.sergeych.lyng.obj.ObjClass?,
|
||||
caller: net.sergeych.lyng.obj.ObjClass?,
|
||||
name: String? = null
|
||||
): Boolean {
|
||||
val res = when (visibility) {
|
||||
Visibility.Public -> true
|
||||
Visibility.Private -> (decl != null && caller === decl)
|
||||
@@ -33,7 +38,14 @@ fun canAccessMember(visibility: Visibility, decl: net.sergeych.lyng.obj.ObjClass
|
||||
decl == null -> false
|
||||
caller == null -> false
|
||||
caller === decl -> true
|
||||
else -> (caller.allParentsSet.contains(decl))
|
||||
caller.allParentsSet.contains(decl) -> true
|
||||
name != null && decl.allParentsSet.contains(caller) -> {
|
||||
// Ancestor can access protected member of its descendant if it also has this member
|
||||
// (i.e. it's an override of something the ancestor knows about)
|
||||
val existing = caller.getInstanceMemberOrNull(name, includeAbstract = true)
|
||||
existing != null && (existing.visibility == Visibility.Protected || existing.visibility == Visibility.Public)
|
||||
}
|
||||
else -> false
|
||||
}
|
||||
}
|
||||
return res
|
||||
|
||||
@@ -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,17 @@ 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 =
|
||||
// We allow optional 'static' as well
|
||||
if (Regex("^(static\\s+)?(override\\s+)?(fun|fn)\\b.*=\\s*$").matches(t)) return true
|
||||
if (Regex("^(static\\s+)?(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 +119,24 @@ 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?
|
||||
// (Note: we exclude 'static' here to avoid double indent if it's already handled)
|
||||
if (Regex("^(override\\s+)?(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 +157,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 +219,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 +232,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--
|
||||
|
||||
@@ -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.
|
||||
@@ -145,6 +145,23 @@ fun ObjClass.addClassFnDoc(
|
||||
}
|
||||
}
|
||||
|
||||
fun ObjClass.addPropertyDoc(
|
||||
name: String,
|
||||
doc: String,
|
||||
type: TypeDoc? = null,
|
||||
visibility: Visibility = Visibility.Public,
|
||||
moduleName: String? = null,
|
||||
getter: (suspend Scope.() -> Obj)? = null,
|
||||
setter: (suspend Scope.(Obj) -> Unit)? = null
|
||||
) {
|
||||
addProperty(name, getter, setter, visibility)
|
||||
BuiltinDocRegistry.module(moduleName ?: ownerModuleNameFromClassOrUnknown()) {
|
||||
classDoc(this@addPropertyDoc.className, doc = "") {
|
||||
field(name = name, doc = doc, type = type, mutable = setter != null)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fun ObjClass.addClassConstDoc(
|
||||
name: String,
|
||||
value: Obj,
|
||||
|
||||
@@ -39,7 +39,77 @@ 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 = mutableListOf<String>()
|
||||
|
||||
fun flush() {
|
||||
currentTag?.let { tag ->
|
||||
val trimmedContent = if (currentContent.size > 1) {
|
||||
// First line is common content, we want to trim indent from subsequent lines
|
||||
// based on THEIR common indent.
|
||||
val firstLine = currentContent[0]
|
||||
val remaining = currentContent.drop(1).joinToString("\n").trimIndent()
|
||||
if (remaining.isEmpty()) firstLine else firstLine + "\n" + remaining
|
||||
} else {
|
||||
currentContent.joinToString("\n")
|
||||
}
|
||||
parsedTags.getOrPut(tag) { mutableListOf() }.add(trimmedContent.trim())
|
||||
}
|
||||
currentContent.clear()
|
||||
}
|
||||
|
||||
val descriptionLines = mutableListOf<String>()
|
||||
var inTags = false
|
||||
|
||||
for (rawLine in lines) {
|
||||
for (line in rawLine.lines()) {
|
||||
// Strip leading '*' and space if present (standard doc comment style)
|
||||
val cleanedLine = line.trim().let {
|
||||
if (it.startsWith("*")) it.substring(1).removePrefix(" ") else line
|
||||
}
|
||||
val trimmed = cleanedLine.trim()
|
||||
if (trimmed.startsWith("@")) {
|
||||
inTags = true
|
||||
flush()
|
||||
val parts = trimmed.substring(1).split(Regex("\\s+"), 2)
|
||||
currentTag = parts[0]
|
||||
val tagFirstLine = parts.getOrNull(1) ?: ""
|
||||
if (tagFirstLine.isNotEmpty()) {
|
||||
// Find where the content starts in the cleaned line to preserve relative indentation
|
||||
val contentIndex = cleanedLine.indexOf(tagFirstLine)
|
||||
if (contentIndex >= 0) {
|
||||
currentContent.add(cleanedLine.substring(contentIndex))
|
||||
} else {
|
||||
currentContent.add(tagFirstLine)
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (inTags) {
|
||||
currentContent.add(cleanedLine)
|
||||
} else {
|
||||
descriptionLines.add(cleanedLine)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
flush()
|
||||
|
||||
val raw = descriptionLines.joinToString("\n").trimIndent().trim()
|
||||
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 +157,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 +185,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 +198,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 +214,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 +224,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 +251,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 +395,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 +435,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
|
||||
|
||||
@@ -93,23 +93,45 @@ open class Obj {
|
||||
args: Arguments = Arguments.EMPTY,
|
||||
onNotFoundResult: (suspend () -> Obj?)? = null
|
||||
): Obj {
|
||||
// 0. Prefer private member of current class context
|
||||
scope.currentClassCtx?.let { caller ->
|
||||
caller.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, caller)
|
||||
} else if (rec.type != ObjRecord.Type.Delegated) {
|
||||
return rec.value.invoke(scope, this, args, caller)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 1. Hierarchy members (excluding root fallback)
|
||||
for (cls in objClass.mro) {
|
||||
if (cls.className == "Obj") break
|
||||
val rec = cls.members[name] ?: cls.classScope?.objects?.get(name)
|
||||
if (rec != null && !rec.isAbstract && rec.type != ObjRecord.Type.Property) {
|
||||
if (rec != null && !rec.isAbstract) {
|
||||
val decl = rec.declaringClass ?: cls
|
||||
val caller = scope.currentClassCtx
|
||||
if (!canAccessMember(rec.visibility, decl, caller))
|
||||
if (!canAccessMember(rec.visibility, decl, caller, name))
|
||||
scope.raiseError(ObjIllegalAccessException(scope, "can't invoke ${name}: not visible (declared in ${decl.className}, caller ${caller?.className ?: "?"})"))
|
||||
return rec.value.invoke(scope, this, args, decl)
|
||||
|
||||
if (rec.type == ObjRecord.Type.Property) {
|
||||
if (args.isEmpty()) return (rec.value as ObjProperty).callGetter(scope, this, decl)
|
||||
} else if (rec.type != ObjRecord.Type.Delegated) {
|
||||
return rec.value.invoke(scope, this, args, decl)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 2. Extensions in scope
|
||||
val extension = scope.findExtension(objClass, name)
|
||||
if (extension != null) {
|
||||
return extension.value.invoke(scope, this, args)
|
||||
if (extension.type == ObjRecord.Type.Property) {
|
||||
if (args.isEmpty()) return (extension.value as ObjProperty).callGetter(scope, this, extension.declaringClass)
|
||||
} else if (extension.type != ObjRecord.Type.Delegated) {
|
||||
return extension.value.invoke(scope, this, args)
|
||||
}
|
||||
}
|
||||
|
||||
// 3. Root object fallback
|
||||
@@ -118,9 +140,14 @@ open class Obj {
|
||||
cls.members[name]?.let { rec ->
|
||||
val decl = rec.declaringClass ?: cls
|
||||
val caller = scope.currentClassCtx
|
||||
if (!canAccessMember(rec.visibility, decl, caller))
|
||||
if (!canAccessMember(rec.visibility, decl, caller, name))
|
||||
scope.raiseError(ObjIllegalAccessException(scope, "can't invoke ${name}: not visible (declared in ${decl.className}, caller ${caller?.className ?: "?"})"))
|
||||
return rec.value.invoke(scope, this, args, decl)
|
||||
|
||||
if (rec.type == ObjRecord.Type.Property) {
|
||||
if (args.isEmpty()) return (rec.value as ObjProperty).callGetter(scope, this, decl)
|
||||
} else if (rec.type != ObjRecord.Type.Delegated) {
|
||||
return rec.value.invoke(scope, this, args, decl)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -402,10 +429,10 @@ open class Obj {
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert Lyng object to its Kotlin counterpart
|
||||
* Convert a Lyng object to its Kotlin counterpart
|
||||
*/
|
||||
open suspend fun toKotlin(scope: Scope): Any? {
|
||||
return toString()
|
||||
return toString(scope).value
|
||||
}
|
||||
|
||||
fun willMutate(scope: Scope) {
|
||||
@@ -415,29 +442,52 @@ open class Obj {
|
||||
// suspend fun <T> sync(block: () -> T): T = monitor.withLock { block() }
|
||||
|
||||
open suspend fun readField(scope: Scope, name: String): ObjRecord {
|
||||
// 0. Prefer private member of current class context
|
||||
scope.currentClassCtx?.let { caller ->
|
||||
caller.members[name]?.let { rec ->
|
||||
if (rec.visibility == Visibility.Private && !rec.isAbstract) {
|
||||
val resolved = resolveRecord(scope, rec, name, caller)
|
||||
if (resolved.type == ObjRecord.Type.Fun && resolved.value is Statement)
|
||||
return resolved.copy(value = resolved.value.invoke(scope, this, Arguments.EMPTY, caller))
|
||||
return resolved
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 1. Hierarchy members (excluding root fallback)
|
||||
for (cls in objClass.mro) {
|
||||
if (cls.className == "Obj") break
|
||||
val rec = cls.members[name] ?: cls.classScope?.objects?.get(name)
|
||||
if (rec != null) {
|
||||
if (!rec.isAbstract) {
|
||||
return resolveRecord(scope, rec, name, rec.declaringClass)
|
||||
}
|
||||
if (rec != null && !rec.isAbstract) {
|
||||
val decl = rec.declaringClass ?: cls
|
||||
val resolved = resolveRecord(scope, rec, name, decl)
|
||||
if (resolved.type == ObjRecord.Type.Fun && resolved.value is Statement)
|
||||
return resolved.copy(value = resolved.value.invoke(scope, this, Arguments.EMPTY, decl))
|
||||
return resolved
|
||||
}
|
||||
}
|
||||
|
||||
// 2. Extensions
|
||||
val extension = scope.findExtension(objClass, name)
|
||||
if (extension != null) {
|
||||
return resolveRecord(scope, extension, name, extension.declaringClass)
|
||||
val resolved = resolveRecord(scope, extension, name, extension.declaringClass)
|
||||
if (resolved.type == ObjRecord.Type.Fun && resolved.value is Statement)
|
||||
return resolved.copy(value = resolved.value.invoke(scope, this, Arguments.EMPTY, extension.declaringClass))
|
||||
return resolved
|
||||
}
|
||||
|
||||
// 3. Root fallback
|
||||
for (cls in objClass.mro) {
|
||||
if (cls.className == "Obj") {
|
||||
cls.members[name]?.let {
|
||||
val decl = it.declaringClass ?: cls
|
||||
return resolveRecord(scope, it, name, decl)
|
||||
cls.members[name]?.let { rec ->
|
||||
val decl = rec.declaringClass ?: cls
|
||||
val caller = scope.currentClassCtx
|
||||
if (!canAccessMember(rec.visibility, decl, caller, name))
|
||||
scope.raiseError(ObjIllegalAccessException(scope, "can't access field ${name}: not visible (declared in ${decl.className}, caller ${caller?.className ?: "?"})"))
|
||||
val resolved = resolveRecord(scope, rec, name, decl)
|
||||
if (resolved.type == ObjRecord.Type.Fun && resolved.value is Statement)
|
||||
return resolved.copy(value = resolved.value.invoke(scope, this, Arguments.EMPTY, decl))
|
||||
return resolved
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -450,21 +500,33 @@ open class Obj {
|
||||
open suspend fun resolveRecord(scope: Scope, obj: ObjRecord, name: String, decl: ObjClass?): ObjRecord {
|
||||
if (obj.type == ObjRecord.Type.Delegated) {
|
||||
val del = obj.delegate ?: scope.raiseError("Internal error: delegated property $name has no delegate")
|
||||
val th = if (this === ObjVoid) ObjNull else this
|
||||
val res = del.invokeInstanceMethod(scope, "getValue", Arguments(th, ObjString(name)), onNotFoundResult = {
|
||||
// If getValue not found, return a wrapper that calls invoke
|
||||
object : Statement() {
|
||||
override val pos: Pos = Pos.builtIn
|
||||
override suspend fun execute(s: Scope): Obj {
|
||||
val th2 = if (s.thisObj === ObjVoid) ObjNull else s.thisObj
|
||||
val allArgs = (listOf(th2, ObjString(name)) + s.args.list).toTypedArray()
|
||||
return del.invokeInstanceMethod(s, "invoke", Arguments(*allArgs))
|
||||
}
|
||||
}
|
||||
})
|
||||
return obj.copy(
|
||||
value = del.invokeInstanceMethod(scope, "getValue", Arguments(this, ObjString(name))),
|
||||
value = res,
|
||||
type = ObjRecord.Type.Other
|
||||
)
|
||||
}
|
||||
val value = obj.value
|
||||
if (value is ObjProperty) {
|
||||
return ObjRecord(value.callGetter(scope, this, decl), obj.isMutable)
|
||||
}
|
||||
if (value is Statement && decl != null) {
|
||||
return ObjRecord(value.execute(scope.createChildScope(scope.pos, newThisObj = this)), obj.isMutable)
|
||||
if (value is ObjProperty || obj.type == ObjRecord.Type.Property) {
|
||||
val prop = if (value is ObjProperty) value else (value as? Statement)?.execute(scope.createChildScope(scope.pos, newThisObj = this)) as? ObjProperty
|
||||
?: scope.raiseError("Expected ObjProperty for property member $name, got ${value::class}")
|
||||
val res = prop.callGetter(scope, this, decl)
|
||||
return ObjRecord(res, obj.isMutable)
|
||||
}
|
||||
val caller = scope.currentClassCtx
|
||||
// Check visibility for non-property members here if they weren't checked before
|
||||
if (!canAccessMember(obj.visibility, decl, caller))
|
||||
if (!canAccessMember(obj.visibility, decl, caller, name))
|
||||
scope.raiseError(ObjIllegalAccessException(scope, "can't access field ${name}: not visible (declared in ${decl?.className ?: "?"}, caller ${caller?.className ?: "?"})"))
|
||||
return obj
|
||||
}
|
||||
@@ -472,13 +534,24 @@ open class Obj {
|
||||
open suspend fun writeField(scope: Scope, name: String, newValue: Obj) {
|
||||
willMutate(scope)
|
||||
var field: ObjRecord? = null
|
||||
// 0. Prefer private member of current class context
|
||||
scope.currentClassCtx?.let { caller ->
|
||||
caller.members[name]?.let { rec ->
|
||||
if (rec.visibility == Visibility.Private && !rec.isAbstract) {
|
||||
field = rec
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 1. Hierarchy members (excluding root fallback)
|
||||
for (cls in objClass.mro) {
|
||||
if (cls.className == "Obj") break
|
||||
val rec = cls.members[name] ?: cls.classScope?.objects?.get(name)
|
||||
if (rec != null && !rec.isAbstract) {
|
||||
field = rec
|
||||
break
|
||||
if (field == null) {
|
||||
for (cls in objClass.mro) {
|
||||
if (cls.className == "Obj") break
|
||||
val rec = cls.members[name] ?: cls.classScope?.objects?.get(name)
|
||||
if (rec != null && !rec.isAbstract) {
|
||||
field = rec
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
// 2. Extensions
|
||||
@@ -501,7 +574,7 @@ open class Obj {
|
||||
|
||||
val decl = field.declaringClass
|
||||
val caller = scope.currentClassCtx
|
||||
if (!canAccessMember(field.effectiveWriteVisibility, decl, caller))
|
||||
if (!canAccessMember(field.effectiveWriteVisibility, decl, caller, name))
|
||||
scope.raiseError(ObjIllegalAccessException(scope, "can't assign field ${name}: not visible (declared in ${decl?.className ?: "?"}, caller ${caller?.className ?: "?"})"))
|
||||
if (field.type == ObjRecord.Type.Delegated) {
|
||||
val del = field.delegate ?: scope.raiseError("Internal error: delegated property $name has no delegate")
|
||||
@@ -512,12 +585,19 @@ open class Obj {
|
||||
}
|
||||
|
||||
open suspend fun getAt(scope: Scope, index: Obj): Obj {
|
||||
if (index is ObjString) {
|
||||
return readField(scope, index.value).value
|
||||
}
|
||||
scope.raiseNotImplemented("indexing")
|
||||
}
|
||||
|
||||
suspend fun getAt(scope: Scope, index: Int): Obj = getAt(scope, ObjInt(index.toLong()))
|
||||
|
||||
open suspend fun putAt(scope: Scope, index: Obj, newValue: Obj) {
|
||||
if (index is ObjString) {
|
||||
writeField(scope, index.value, newValue)
|
||||
return
|
||||
}
|
||||
scope.raiseNotImplemented("indexing")
|
||||
}
|
||||
|
||||
@@ -680,12 +760,42 @@ open class Obj {
|
||||
) {
|
||||
thisObj.toJson(this).toString().toObj()
|
||||
}
|
||||
addFnDoc(
|
||||
name = "clamp",
|
||||
doc = "Clamps this value within the specified range. If the value is outside the range, it is set to the nearest boundary. Respects inclusive/exclusive range ends.",
|
||||
params = listOf(ParamDoc("range")),
|
||||
moduleName = "lyng.stdlib"
|
||||
) {
|
||||
val range = requiredArg<ObjRange>(0)
|
||||
|
||||
var result = thisObj
|
||||
if (range.start != null && !range.start.isNull) {
|
||||
if (result.compareTo(this, range.start) < 0) {
|
||||
result = range.start
|
||||
}
|
||||
}
|
||||
if (range.end != null && !range.end.isNull) {
|
||||
val cmp = range.end.compareTo(this, result)
|
||||
if (range.isEndInclusive) {
|
||||
if (cmp < 0) result = range.end
|
||||
} else {
|
||||
if (cmp <= 0) {
|
||||
if (range.end is ObjInt) {
|
||||
result = ObjInt.of(range.end.value - 1)
|
||||
} else if (range.end is ObjChar) {
|
||||
result = ObjChar((range.end.value.code - 1).toChar())
|
||||
} else {
|
||||
result = range.end
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
result
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
inline fun from(obj: Any?): Obj {
|
||||
@Suppress("UNCHECKED_CAST")
|
||||
fun from(obj: Any?): Obj {
|
||||
return when (obj) {
|
||||
is Obj -> obj
|
||||
is Double -> ObjReal(obj)
|
||||
@@ -694,16 +804,16 @@ open class Obj {
|
||||
is Long -> ObjInt.of(obj)
|
||||
is String -> ObjString(obj)
|
||||
is CharSequence -> ObjString(obj.toString())
|
||||
is Char -> ObjChar(obj)
|
||||
is Boolean -> ObjBool(obj)
|
||||
is Set<*> -> ObjSet((obj as Set<Obj>).toMutableSet())
|
||||
is Set<*> -> ObjSet(obj.map { from(it) }.toMutableSet())
|
||||
is List<*> -> ObjList(obj.map { from(it) }.toMutableList())
|
||||
is Map<*, *> -> ObjMap(obj.entries.associate { from(it.key) to from(it.value) }.toMutableMap())
|
||||
is Map.Entry<*, *> -> ObjMapEntry(from(obj.key), from(obj.value))
|
||||
is Enum<*> -> ObjString(obj.name)
|
||||
Unit -> ObjVoid
|
||||
null -> ObjNull
|
||||
is Iterator<*> -> ObjKotlinIterator(obj)
|
||||
is Map.Entry<*, *> -> {
|
||||
obj as MutableMap.MutableEntry<Obj, Obj>
|
||||
ObjMapEntry(obj.key, obj.value)
|
||||
}
|
||||
|
||||
is Iterator<*> -> ObjKotlinIterator(obj as Iterator<Any?>)
|
||||
else -> throw IllegalArgumentException("cannot convert to Obj: $obj")
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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.
|
||||
@@ -17,10 +17,7 @@
|
||||
|
||||
package net.sergeych.lyng.obj
|
||||
|
||||
import net.sergeych.lyng.miniast.ParamDoc
|
||||
import net.sergeych.lyng.miniast.TypeGenericDoc
|
||||
import net.sergeych.lyng.miniast.addFnDoc
|
||||
import net.sergeych.lyng.miniast.type
|
||||
import net.sergeych.lyng.miniast.*
|
||||
|
||||
val ObjArray by lazy {
|
||||
|
||||
@@ -52,32 +49,35 @@ val ObjArray by lazy {
|
||||
ObjFalse
|
||||
}
|
||||
|
||||
addFnDoc(
|
||||
addPropertyDoc(
|
||||
name = "last",
|
||||
doc = "The last element of this array.",
|
||||
returns = type("lyng.Any"),
|
||||
moduleName = "lyng.stdlib"
|
||||
) {
|
||||
thisObj.invokeInstanceMethod(
|
||||
this,
|
||||
"getAt",
|
||||
(thisObj.invokeInstanceMethod(this, "size").toInt() - 1).toObj()
|
||||
)
|
||||
}
|
||||
type = type("lyng.Any"),
|
||||
moduleName = "lyng.stdlib",
|
||||
getter = {
|
||||
this.thisObj.invokeInstanceMethod(
|
||||
this,
|
||||
"getAt",
|
||||
(this.thisObj.invokeInstanceMethod(this, "size").toInt() - 1).toObj()
|
||||
)
|
||||
}
|
||||
)
|
||||
|
||||
addFnDoc(
|
||||
addPropertyDoc(
|
||||
name = "lastIndex",
|
||||
doc = "Index of the last element (size - 1).",
|
||||
returns = type("lyng.Int"),
|
||||
moduleName = "lyng.stdlib"
|
||||
) { (thisObj.invokeInstanceMethod(this, "size").toInt() - 1).toObj() }
|
||||
type = type("lyng.Int"),
|
||||
moduleName = "lyng.stdlib",
|
||||
getter = { (this.thisObj.invokeInstanceMethod(this, "size").toInt() - 1).toObj() }
|
||||
)
|
||||
|
||||
addFnDoc(
|
||||
addPropertyDoc(
|
||||
name = "indices",
|
||||
doc = "Range of valid indices for this array.",
|
||||
returns = type("lyng.Range"),
|
||||
moduleName = "lyng.stdlib"
|
||||
) { ObjRange(0.toObj(), thisObj.invokeInstanceMethod(this, "size"), false) }
|
||||
type = type("lyng.Range"),
|
||||
moduleName = "lyng.stdlib",
|
||||
getter = { ObjRange(0.toObj(), this.thisObj.invokeInstanceMethod(this, "size"), false) }
|
||||
)
|
||||
|
||||
addFnDoc(
|
||||
name = "binarySearch",
|
||||
|
||||
@@ -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,6 +19,8 @@ package net.sergeych.lyng.obj
|
||||
|
||||
import net.sergeych.bintools.toDump
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.miniast.addPropertyDoc
|
||||
import net.sergeych.lyng.miniast.type
|
||||
import net.sergeych.lynon.BitArray
|
||||
|
||||
class ObjBitBuffer(val bitArray: BitArray) : Obj() {
|
||||
@@ -43,12 +45,20 @@ class ObjBitBuffer(val bitArray: BitArray) : Obj() {
|
||||
thisAs<ObjBitBuffer>().bitArray.asUByteArray().toDump()
|
||||
)
|
||||
}
|
||||
addFn("size") {
|
||||
thisAs<ObjBitBuffer>().bitArray.size.toObj()
|
||||
}
|
||||
addFn("sizeInBytes") {
|
||||
ObjInt((thisAs<ObjBitBuffer>().bitArray.size + 7) shr 3)
|
||||
}
|
||||
addPropertyDoc(
|
||||
name = "size",
|
||||
doc = "Size of the bit buffer in bits.",
|
||||
type = type("lyng.Int"),
|
||||
moduleName = "lyng.stdlib",
|
||||
getter = { thisAs<ObjBitBuffer>().bitArray.size.toObj() }
|
||||
)
|
||||
addPropertyDoc(
|
||||
name = "sizeInBytes",
|
||||
doc = "Size of the bit buffer in full bytes (rounded up).",
|
||||
type = type("lyng.Int"),
|
||||
moduleName = "lyng.stdlib",
|
||||
getter = { ObjInt((thisAs<ObjBitBuffer>().bitArray.size + 7) shr 3) }
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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,8 @@ import net.sergeych.bintools.decodeHex
|
||||
import net.sergeych.bintools.encodeToHex
|
||||
import net.sergeych.bintools.toDump
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.statement
|
||||
import net.sergeych.lyng.miniast.addPropertyDoc
|
||||
import net.sergeych.lyng.miniast.type
|
||||
import net.sergeych.lynon.BitArray
|
||||
import net.sergeych.lynon.LynonDecoder
|
||||
import net.sergeych.lynon.LynonEncoder
|
||||
@@ -174,20 +175,26 @@ open class ObjBuffer(val byteArray: UByteArray) : Obj() {
|
||||
addClassFn("decodeHex") {
|
||||
ObjBuffer(requireOnlyArg<Obj>().toString().decodeHex().asUByteArray())
|
||||
}
|
||||
createField("size",
|
||||
statement {
|
||||
(thisObj as ObjBuffer).byteArray.size.toObj()
|
||||
}
|
||||
addPropertyDoc(
|
||||
name = "size",
|
||||
doc = "Number of bytes in this buffer.",
|
||||
type = type("lyng.Int"),
|
||||
moduleName = "lyng.stdlib",
|
||||
getter = { (this.thisObj as ObjBuffer).byteArray.size.toObj() }
|
||||
)
|
||||
createField("hex",
|
||||
statement {
|
||||
thisAs<ObjBuffer>().hex.toObj()
|
||||
}
|
||||
addPropertyDoc(
|
||||
name = "hex",
|
||||
doc = "Hexadecimal string representation of the buffer.",
|
||||
type = type("lyng.String"),
|
||||
moduleName = "lyng.stdlib",
|
||||
getter = { thisAs<ObjBuffer>().hex.toObj() }
|
||||
)
|
||||
createField("base64",
|
||||
statement {
|
||||
thisAs<ObjBuffer>().base64.toObj()
|
||||
}
|
||||
addPropertyDoc(
|
||||
name = "base64",
|
||||
doc = "Base64 (URL-safe) string representation of the buffer.",
|
||||
type = type("lyng.String"),
|
||||
moduleName = "lyng.stdlib",
|
||||
getter = { thisAs<ObjBuffer>().base64.toObj() }
|
||||
)
|
||||
addFn("decodeUtf8") {
|
||||
ObjString(
|
||||
|
||||
@@ -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,7 @@
|
||||
package net.sergeych.lyng.obj
|
||||
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.miniast.addFnDoc
|
||||
import net.sergeych.lyng.miniast.addPropertyDoc
|
||||
import net.sergeych.lyng.miniast.type
|
||||
|
||||
class ObjChar(val value: Char): Obj() {
|
||||
@@ -47,12 +47,13 @@ class ObjChar(val value: Char): Obj() {
|
||||
|
||||
companion object {
|
||||
val type = ObjClass("Char").apply {
|
||||
addFnDoc(
|
||||
addPropertyDoc(
|
||||
name = "code",
|
||||
doc = "Unicode code point (UTF-16 code unit) of this character.",
|
||||
returns = type("lyng.Int"),
|
||||
moduleName = "lyng.stdlib"
|
||||
) { ObjInt(thisAs<ObjChar>().value.code.toLong()) }
|
||||
type = type("lyng.Int"),
|
||||
moduleName = "lyng.stdlib",
|
||||
getter = { ObjInt((this.thisObj as ObjChar).value.code.toLong()) }
|
||||
)
|
||||
addFn("isDigit") {
|
||||
thisAs<ObjChar>().value.isDigit().toObj()
|
||||
}
|
||||
|
||||
@@ -17,60 +17,74 @@
|
||||
|
||||
package net.sergeych.lyng.obj
|
||||
|
||||
import kotlinx.serialization.json.JsonElement
|
||||
import kotlinx.serialization.json.JsonObject
|
||||
import net.sergeych.lyng.*
|
||||
import net.sergeych.lyng.miniast.ParamDoc
|
||||
import net.sergeych.lyng.miniast.TypeGenericDoc
|
||||
import net.sergeych.lyng.miniast.addFnDoc
|
||||
import net.sergeych.lyng.miniast.type
|
||||
import net.sergeych.lyng.miniast.*
|
||||
import net.sergeych.lynon.LynonDecoder
|
||||
import net.sergeych.lynon.LynonEncoder
|
||||
import net.sergeych.lynon.LynonType
|
||||
|
||||
// Simple id generator for class identities (not thread-safe; fine for scripts)
|
||||
private object ClassIdGen { var c: Long = 1L; fun nextId(): Long = c++ }
|
||||
|
||||
val ObjClassType by lazy {
|
||||
ObjClass("Class").apply {
|
||||
addProperty("className", getter = { thisAs<ObjClass>().classNameObj })
|
||||
addFnDoc(
|
||||
object : ObjClass("Class") {
|
||||
override suspend fun deserialize(scope: Scope, decoder: LynonDecoder, lynonType: LynonType?): Obj {
|
||||
val name = decoder.decodeObject(scope, ObjString.type, null) as ObjString
|
||||
return scope.resolveQualifiedIdentifier(name.value)
|
||||
}
|
||||
}.apply {
|
||||
addPropertyDoc(
|
||||
name = "className",
|
||||
doc = "Full name of this class including package if available.",
|
||||
type = type("lyng.String"),
|
||||
moduleName = "lyng.stdlib",
|
||||
getter = { (this.thisObj as ObjClass).classNameObj }
|
||||
)
|
||||
addPropertyDoc(
|
||||
name = "name",
|
||||
doc = "Simple name of this class (without package).",
|
||||
returns = type("lyng.String"),
|
||||
moduleName = "lyng.stdlib"
|
||||
) { thisAs<ObjClass>().classNameObj }
|
||||
type = type("lyng.String"),
|
||||
moduleName = "lyng.stdlib",
|
||||
getter = { (this.thisObj as ObjClass).classNameObj }
|
||||
)
|
||||
|
||||
addFnDoc(
|
||||
addPropertyDoc(
|
||||
name = "fields",
|
||||
doc = "Declared instance fields of this class and its ancestors (C3 order), without duplicates.",
|
||||
returns = TypeGenericDoc(type("lyng.List"), listOf(type("lyng.String"))),
|
||||
moduleName = "lyng.stdlib"
|
||||
) {
|
||||
val cls = thisAs<ObjClass>()
|
||||
val seen = hashSetOf<String>()
|
||||
val names = mutableListOf<Obj>()
|
||||
for (c in cls.mro) {
|
||||
for ((n, rec) in c.members) {
|
||||
if (rec.value !is Statement && seen.add(n)) names += ObjString(n)
|
||||
type = TypeGenericDoc(type("lyng.List"), listOf(type("lyng.String"))),
|
||||
moduleName = "lyng.stdlib",
|
||||
getter = {
|
||||
val cls = this.thisObj as ObjClass
|
||||
val seen = hashSetOf<String>()
|
||||
val names = mutableListOf<Obj>()
|
||||
for (c in cls.mro) {
|
||||
for ((n, rec) in c.members) {
|
||||
if (rec.value !is Statement && seen.add(n)) names += ObjString(n)
|
||||
}
|
||||
}
|
||||
ObjList(names.toMutableList())
|
||||
}
|
||||
ObjList(names.toMutableList())
|
||||
}
|
||||
)
|
||||
|
||||
addFnDoc(
|
||||
addPropertyDoc(
|
||||
name = "methods",
|
||||
doc = "Declared instance methods of this class and its ancestors (C3 order), without duplicates.",
|
||||
returns = TypeGenericDoc(type("lyng.List"), listOf(type("lyng.String"))),
|
||||
moduleName = "lyng.stdlib"
|
||||
) {
|
||||
val cls = thisAs<ObjClass>()
|
||||
val seen = hashSetOf<String>()
|
||||
val names = mutableListOf<Obj>()
|
||||
for (c in cls.mro) {
|
||||
for ((n, rec) in c.members) {
|
||||
if (rec.value is Statement && seen.add(n)) names += ObjString(n)
|
||||
type = TypeGenericDoc(type("lyng.List"), listOf(type("lyng.String"))),
|
||||
moduleName = "lyng.stdlib",
|
||||
getter = {
|
||||
val cls = this.thisObj as ObjClass
|
||||
val seen = hashSetOf<String>()
|
||||
val names = mutableListOf<Obj>()
|
||||
for (c in cls.mro) {
|
||||
for ((n, rec) in c.members) {
|
||||
if (rec.value is Statement && seen.add(n)) names += ObjString(n)
|
||||
}
|
||||
}
|
||||
ObjList(names.toMutableList())
|
||||
}
|
||||
ObjList(names.toMutableList())
|
||||
}
|
||||
)
|
||||
|
||||
addFnDoc(
|
||||
name = "get",
|
||||
@@ -100,6 +114,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
|
||||
@@ -236,6 +278,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.
|
||||
@@ -250,20 +329,10 @@ open class ObjClass(
|
||||
instance.instanceScope.currentClassCtx = null
|
||||
// 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
|
||||
// 1) members-defined methods
|
||||
for ((k, v) in members) {
|
||||
if (v.value is Statement || v.type == ObjRecord.Type.Delegated) {
|
||||
instance.instanceScope.objects[k] = if (v.type == ObjRecord.Type.Delegated) v.copy() else v
|
||||
}
|
||||
}
|
||||
// 2) class-scope methods registered during class-body execution
|
||||
classScope?.objects?.forEach { (k, rec) ->
|
||||
if (rec.value is Statement || rec.type == ObjRecord.Type.Delegated) {
|
||||
// if not already present, copy reference for dispatch
|
||||
if (!instance.instanceScope.objects.containsKey(k)) {
|
||||
instance.instanceScope.objects[k] = if (rec.type == ObjRecord.Type.Delegated) rec.copy() else rec
|
||||
}
|
||||
}
|
||||
|
||||
instance.instanceScope.objects.putAll(templateMethods)
|
||||
for (p in templateOthers) {
|
||||
instance.instanceScope.objects[p.first] = p.second.copy()
|
||||
}
|
||||
return instance
|
||||
}
|
||||
@@ -300,13 +369,19 @@ open class ObjClass(
|
||||
c.constructorMeta?.let { meta ->
|
||||
val argsHere = argsForThis ?: Arguments.EMPTY
|
||||
// Assign constructor params into instance scope (unmangled)
|
||||
meta.assignToContext(instance.instanceScope, argsHere, declaringClass = c)
|
||||
val savedCtx = instance.instanceScope.currentClassCtx
|
||||
instance.instanceScope.currentClassCtx = c
|
||||
try {
|
||||
meta.assignToContext(instance.instanceScope, argsHere, declaringClass = c)
|
||||
} finally {
|
||||
instance.instanceScope.currentClassCtx = savedCtx
|
||||
}
|
||||
// Also expose them under MI-mangled storage keys `${Class}::name` so qualified views can access them
|
||||
// and so that base-class casts like `(obj as Base).field` work.
|
||||
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
|
||||
@@ -329,12 +404,18 @@ open class ObjClass(
|
||||
// parameters even if they were shadowed/overwritten by parent class initialization.
|
||||
c.constructorMeta?.let { meta ->
|
||||
val argsHere = argsForThis ?: Arguments.EMPTY
|
||||
meta.assignToContext(instance.instanceScope, argsHere, declaringClass = c)
|
||||
val savedCtx = instance.instanceScope.currentClassCtx
|
||||
instance.instanceScope.currentClassCtx = c
|
||||
try {
|
||||
meta.assignToContext(instance.instanceScope, argsHere, declaringClass = c)
|
||||
} finally {
|
||||
instance.instanceScope.currentClassCtx = savedCtx
|
||||
}
|
||||
// Re-sync mangled names to point to the fresh records to keep them consistent
|
||||
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
|
||||
}
|
||||
}
|
||||
@@ -378,16 +459,18 @@ open class ObjClass(
|
||||
isAbstract: Boolean = false,
|
||||
isClosed: Boolean = false,
|
||||
isOverride: Boolean = false,
|
||||
isTransient: Boolean = false,
|
||||
type: ObjRecord.Type = ObjRecord.Type.Field,
|
||||
): ObjRecord {
|
||||
// Validation of override rules: only for non-system declarations
|
||||
if (pos != Pos.builtIn) {
|
||||
val existing = getInstanceMemberOrNull(name)
|
||||
// Only consider TRUE instance members from ancestors for overrides
|
||||
val existing = getInstanceMemberOrNull(name, includeAbstract = true, includeStatic = false)
|
||||
var actualOverride = false
|
||||
if (existing != null && existing.declaringClass != this) {
|
||||
// If the existing member is private in the ancestor, it's not visible for overriding.
|
||||
// It should be treated as a new member in this class.
|
||||
if (!existing.visibility.isPublic && !canAccessMember(existing.visibility, existing.declaringClass, this)) {
|
||||
if (!existing.visibility.isPublic && !canAccessMember(existing.visibility, existing.declaringClass, this, name)) {
|
||||
// It's effectively not there for us, so actualOverride remains false
|
||||
} else {
|
||||
actualOverride = true
|
||||
@@ -420,6 +503,7 @@ open class ObjClass(
|
||||
isAbstract = isAbstract,
|
||||
isClosed = isClosed,
|
||||
isOverride = isOverride,
|
||||
isTransient = isTransient,
|
||||
type = type
|
||||
)
|
||||
members[name] = rec
|
||||
@@ -440,13 +524,14 @@ open class ObjClass(
|
||||
visibility: Visibility = Visibility.Public,
|
||||
writeVisibility: Visibility? = null,
|
||||
pos: Pos = Pos.builtIn,
|
||||
isTransient: Boolean = false,
|
||||
type: ObjRecord.Type = ObjRecord.Type.Field
|
||||
): ObjRecord {
|
||||
initClassScope()
|
||||
val existing = classScope!!.objects[name]
|
||||
if (existing != null)
|
||||
throw ScriptError(pos, "$name is already defined in $objClass or one of its supertypes")
|
||||
val rec = classScope!!.addItem(name, isMutable, initialValue, visibility, writeVisibility, recordType = type)
|
||||
val rec = classScope!!.addItem(name, isMutable, initialValue, visibility, writeVisibility, recordType = type, isTransient = isTransient)
|
||||
// Structural change: bump layout version for PIC invalidation
|
||||
layoutVersion += 1
|
||||
return rec
|
||||
@@ -485,12 +570,13 @@ open class ObjClass(
|
||||
isClosed: Boolean = false,
|
||||
isOverride: Boolean = false,
|
||||
pos: Pos = Pos.builtIn,
|
||||
prop: ObjProperty? = null
|
||||
) {
|
||||
val g = getter?.let { statement { it() } }
|
||||
val s = setter?.let { statement { it(requiredArg(0)); ObjVoid } }
|
||||
val prop = if (isAbstract) ObjNull else ObjProperty(name, g, s)
|
||||
val finalProp = prop ?: if (isAbstract) ObjNull else ObjProperty(name, g, s)
|
||||
createField(
|
||||
name, prop, false, visibility, writeVisibility, pos, declaringClass,
|
||||
name, finalProp, false, visibility, writeVisibility, pos, declaringClass,
|
||||
isAbstract = isAbstract, isClosed = isClosed, isOverride = isOverride,
|
||||
type = ObjRecord.Type.Property
|
||||
)
|
||||
@@ -505,14 +591,21 @@ open class ObjClass(
|
||||
/**
|
||||
* Get instance member traversing the hierarchy if needed. Its meaning is different for different objects.
|
||||
*/
|
||||
fun getInstanceMemberOrNull(name: String): ObjRecord? {
|
||||
fun getInstanceMemberOrNull(name: String, includeAbstract: Boolean = false, includeStatic: Boolean = true): ObjRecord? {
|
||||
// Unified traversal in strict C3 order: self, then each ancestor, checking members before classScope
|
||||
for (cls in mro) {
|
||||
cls.members[name]?.let { return it }
|
||||
cls.classScope?.objects?.get(name)?.let { return it }
|
||||
cls.members[name]?.let {
|
||||
if (includeAbstract || !it.isAbstract) return it
|
||||
}
|
||||
if (includeStatic) {
|
||||
cls.classScope?.objects?.get(name)?.let {
|
||||
if (includeAbstract || !it.isAbstract) return it
|
||||
}
|
||||
}
|
||||
}
|
||||
// Finally, allow root object fallback (rare; mostly built-ins like toString)
|
||||
return rootObjectType.members[name]
|
||||
val rootRec = rootObjectType.members[name]
|
||||
return if (rootRec != null && (includeAbstract || !rootRec.isAbstract)) rootRec else null
|
||||
}
|
||||
|
||||
/** Find the declaring class where a member with [name] is defined, starting from this class along MRO. */
|
||||
@@ -625,6 +718,22 @@ open class ObjClass(
|
||||
return super.invokeInstanceMethod(scope, name, args, onNotFoundResult)
|
||||
}
|
||||
|
||||
override suspend fun serialize(scope: Scope, encoder: LynonEncoder, lynonType: LynonType?) {
|
||||
if (isAnonymous) scope.raiseError("Cannot serialize anonymous class")
|
||||
encoder.encodeObject(scope, classNameObj, ObjString.type.lynonType())
|
||||
}
|
||||
|
||||
override suspend fun toJson(scope: Scope): JsonElement {
|
||||
val result = mutableMapOf<String, JsonElement>()
|
||||
result["__class_name"] = classNameObj.toJson(scope)
|
||||
classScope?.objects?.forEach { (name, rec) ->
|
||||
if (rec.type.serializable && rec.visibility.isPublic && !rec.isTransient) {
|
||||
result[name] = rec.value.toJson(scope)
|
||||
}
|
||||
}
|
||||
return JsonObject(result)
|
||||
}
|
||||
|
||||
open suspend fun deserialize(scope: Scope, decoder: LynonDecoder, lynonType: LynonType?): Obj =
|
||||
scope.raiseNotImplemented()
|
||||
|
||||
|
||||
@@ -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,5 +21,6 @@ package net.sergeych.lyng.obj
|
||||
* Collection is an iterator with `size`
|
||||
*/
|
||||
val ObjCollection = ObjClass("Collection", ObjIterable).apply {
|
||||
addProperty("size", isAbstract = true)
|
||||
}
|
||||
|
||||
@@ -0,0 +1,293 @@
|
||||
/*
|
||||
* 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.obj
|
||||
|
||||
import kotlinx.datetime.*
|
||||
import kotlinx.serialization.json.JsonElement
|
||||
import kotlinx.serialization.json.JsonPrimitive
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.Statement
|
||||
import net.sergeych.lyng.miniast.addClassFnDoc
|
||||
import net.sergeych.lyng.miniast.addFnDoc
|
||||
import net.sergeych.lyng.miniast.addPropertyDoc
|
||||
import net.sergeych.lyng.miniast.type
|
||||
import net.sergeych.lynon.LynonDecoder
|
||||
import net.sergeych.lynon.LynonEncoder
|
||||
import net.sergeych.lynon.LynonType
|
||||
|
||||
class ObjDateTime(val instant: Instant, val timeZone: TimeZone) : Obj() {
|
||||
override val objClass: ObjClass get() = type
|
||||
|
||||
val localDateTime: LocalDateTime by lazy {
|
||||
instant.toLocalDateTime(timeZone)
|
||||
}
|
||||
|
||||
override fun toString(): String {
|
||||
return localDateTime.toString() + timeZone.toString()
|
||||
}
|
||||
|
||||
override suspend fun readField(scope: Scope, name: String): ObjRecord {
|
||||
for (cls in objClass.mro) {
|
||||
val rec = cls.members[name]
|
||||
if (rec != null) {
|
||||
if (rec.type == ObjRecord.Type.Property) {
|
||||
val prop = rec.value as? ObjProperty
|
||||
?: (rec.value as? Statement)?.execute(scope) as? ObjProperty
|
||||
if (prop != null) {
|
||||
return ObjRecord(prop.callGetter(scope, this, rec.declaringClass ?: cls), rec.isMutable)
|
||||
}
|
||||
}
|
||||
if (rec.type == ObjRecord.Type.Fun || rec.value is Statement) {
|
||||
val s = rec.value as Statement
|
||||
return ObjRecord(net.sergeych.lyng.statement { s.execute(this.createChildScope(newThisObj = this@ObjDateTime)) }, rec.isMutable)
|
||||
}
|
||||
return resolveRecord(scope, rec, name, rec.declaringClass ?: cls)
|
||||
}
|
||||
}
|
||||
return super.readField(scope, name)
|
||||
}
|
||||
|
||||
override suspend fun plus(scope: Scope, other: Obj): Obj {
|
||||
return when (other) {
|
||||
is ObjDuration -> ObjDateTime(instant + other.duration, timeZone)
|
||||
else -> super.plus(scope, other)
|
||||
}
|
||||
}
|
||||
|
||||
override suspend fun minus(scope: Scope, other: Obj): Obj {
|
||||
return when (other) {
|
||||
is ObjDuration -> ObjDateTime(instant - other.duration, timeZone)
|
||||
is ObjDateTime -> ObjDuration(instant - other.instant)
|
||||
is ObjInstant -> ObjDuration(instant - other.instant)
|
||||
else -> super.minus(scope, other)
|
||||
}
|
||||
}
|
||||
|
||||
override suspend fun compareTo(scope: Scope, other: Obj): Int {
|
||||
if (other is ObjDateTime) {
|
||||
return instant.compareTo(other.instant)
|
||||
}
|
||||
if (other is ObjInstant) {
|
||||
return instant.compareTo(other.instant)
|
||||
}
|
||||
return super.compareTo(scope, other)
|
||||
}
|
||||
|
||||
override suspend fun toKotlin(scope: Scope): Any {
|
||||
return localDateTime
|
||||
}
|
||||
|
||||
override fun hashCode(): Int {
|
||||
return instant.hashCode() xor timeZone.hashCode()
|
||||
}
|
||||
|
||||
override fun equals(other: Any?): Boolean {
|
||||
if (this === other) return true
|
||||
if (other !is ObjDateTime) return false
|
||||
return instant == other.instant && timeZone == other.timeZone
|
||||
}
|
||||
|
||||
override suspend fun lynonType(): LynonType = LynonType.Other
|
||||
|
||||
override suspend fun serialize(scope: Scope, encoder: LynonEncoder, lynonType: LynonType?) {
|
||||
encoder.encodeCached(this) {
|
||||
encodeAny(scope, ObjInstant(instant))
|
||||
encodeCached(timeZone.id) {
|
||||
encodeBinaryData(timeZone.id.encodeToByteArray())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
override suspend fun toJson(scope: Scope): JsonElement = JsonPrimitive(toRFC3339())
|
||||
|
||||
fun toRFC3339(): String {
|
||||
val s = localDateTime.toString()
|
||||
val tz = if (timeZone == TimeZone.UTC) "Z" else timeZone.id
|
||||
return if (tz.startsWith("+") || tz.startsWith("-") || tz == "Z") s + tz else s + "[" + tz + "]"
|
||||
}
|
||||
|
||||
companion object {
|
||||
val type = object : ObjClass("DateTime") {
|
||||
override suspend fun callOn(scope: Scope): Obj {
|
||||
val args = scope.args
|
||||
return when (val a0 = args.list.getOrNull(0)) {
|
||||
is ObjInstant -> {
|
||||
val tz = when (val a1 = args.list.getOrNull(1)) {
|
||||
null -> TimeZone.currentSystemDefault()
|
||||
is ObjString -> TimeZone.of(a1.value)
|
||||
is ObjInt -> UtcOffset(seconds = a1.value.toInt()).asTimeZone()
|
||||
else -> scope.raiseIllegalArgument("invalid timezone: $a1")
|
||||
}
|
||||
ObjDateTime(a0.instant, tz)
|
||||
}
|
||||
|
||||
is ObjInt -> {
|
||||
// DateTime(year, month, day, hour=0, minute=0, second=0, timeZone="UTC")
|
||||
val year = a0.value.toInt()
|
||||
val month = args.list.getOrNull(1)?.toInt() ?: scope.raiseIllegalArgument("month is required")
|
||||
val day = args.list.getOrNull(2)?.toInt() ?: scope.raiseIllegalArgument("day is required")
|
||||
val hour = args.list.getOrNull(3)?.toInt() ?: 0
|
||||
val minute = args.list.getOrNull(4)?.toInt() ?: 0
|
||||
val second = args.list.getOrNull(5)?.toInt() ?: 0
|
||||
val tz = when (val a6 = args.list.getOrNull(6)) {
|
||||
null -> TimeZone.UTC
|
||||
is ObjString -> TimeZone.of(a6.value)
|
||||
is ObjInt -> UtcOffset(seconds = a6.value.toInt()).asTimeZone()
|
||||
else -> scope.raiseIllegalArgument("invalid timezone: $a6")
|
||||
}
|
||||
val ldt = LocalDateTime(year, month, day, hour, minute, second)
|
||||
ObjDateTime(ldt.toInstant(tz), tz)
|
||||
}
|
||||
|
||||
is ObjString -> {
|
||||
val instant = Instant.parse(a0.value)
|
||||
ObjDateTime(instant, TimeZone.UTC)
|
||||
}
|
||||
|
||||
else -> scope.raiseIllegalArgument("can't construct DateTime from ${args.inspect(scope)}")
|
||||
}
|
||||
}
|
||||
|
||||
override suspend fun deserialize(scope: Scope, decoder: LynonDecoder, lynonType: LynonType?): Obj {
|
||||
return decoder.decodeCached {
|
||||
val instant = (decoder.decodeAny(scope) as ObjInstant).instant
|
||||
val tzId = decoder.decodeCached { decoder.unpackBinaryData().decodeToString() }
|
||||
ObjDateTime(instant, TimeZone.of(tzId))
|
||||
}
|
||||
}
|
||||
}.apply {
|
||||
addPropertyDoc("year", "The year component.", type("lyng.Int"), moduleName = "lyng.time",
|
||||
getter = { thisAs<ObjDateTime>().localDateTime.year.toObj() })
|
||||
addPropertyDoc("month", "The month component (1..12).", type("lyng.Int"), moduleName = "lyng.time",
|
||||
getter = { thisAs<ObjDateTime>().localDateTime.monthNumber.toObj() })
|
||||
addPropertyDoc("dayOfMonth", "The day of month component.", type("lyng.Int"), moduleName = "lyng.time",
|
||||
getter = { thisAs<ObjDateTime>().localDateTime.dayOfMonth.toObj() })
|
||||
addPropertyDoc("day", "Alias to dayOfMonth.", type("lyng.Int"), moduleName = "lyng.time",
|
||||
getter = { thisAs<ObjDateTime>().localDateTime.dayOfMonth.toObj() })
|
||||
addPropertyDoc("hour", "The hour component (0..23).", type("lyng.Int"), moduleName = "lyng.time",
|
||||
getter = { thisAs<ObjDateTime>().localDateTime.hour.toObj() })
|
||||
addPropertyDoc("minute", "The minute component (0..59).", type("lyng.Int"), moduleName = "lyng.time",
|
||||
getter = { thisAs<ObjDateTime>().localDateTime.minute.toObj() })
|
||||
addPropertyDoc("second", "The second component (0..59).", type("lyng.Int"), moduleName = "lyng.time",
|
||||
getter = { thisAs<ObjDateTime>().localDateTime.second.toObj() })
|
||||
addPropertyDoc("dayOfWeek", "The day of week (1=Monday, 7=Sunday).", type("lyng.Int"), moduleName = "lyng.time",
|
||||
getter = { thisAs<ObjDateTime>().localDateTime.dayOfWeek.isoDayNumber.toObj() })
|
||||
addPropertyDoc("timeZone", "The time zone ID (e.g. 'Z', '+02:00', 'Europe/Prague').", type("lyng.String"), moduleName = "lyng.time",
|
||||
getter = { thisAs<ObjDateTime>().timeZone.id.toObj() })
|
||||
|
||||
addFnDoc("toInstant", "Convert this localized date time back to an absolute Instant.", returns = type("lyng.Instant"), moduleName = "lyng.time") {
|
||||
ObjInstant(thisAs<ObjDateTime>().instant)
|
||||
}
|
||||
addFnDoc("toEpochSeconds", "Return the number of full seconds since the Unix epoch (UTC).", returns = type("lyng.Int"), moduleName = "lyng.time") {
|
||||
thisAs<ObjDateTime>().instant.epochSeconds.toObj()
|
||||
}
|
||||
addFnDoc("toRFC3339", "Return the RFC3339 string representation of this date time, including its timezone offset.", returns = type("lyng.String"), moduleName = "lyng.time") {
|
||||
thisAs<ObjDateTime>().toRFC3339().toObj()
|
||||
}
|
||||
addFnDoc("toSortableString", "Alias to toRFC3339.", returns = type("lyng.String"), moduleName = "lyng.time") {
|
||||
thisAs<ObjDateTime>().toRFC3339().toObj()
|
||||
}
|
||||
|
||||
addFnDoc("toEpochMilliseconds", "Return the number of milliseconds since the Unix epoch (UTC).", returns = type("lyng.Int"), moduleName = "lyng.time") {
|
||||
thisAs<ObjDateTime>().instant.toEpochMilliseconds().toObj()
|
||||
}
|
||||
addFnDoc("toTimeZone", "Return a new DateTime representing the same instant but in a different time zone. " +
|
||||
"Accepts a timezone ID string (e.g., 'UTC', '+02:00') or an integer offset in seconds.",
|
||||
params = listOf(net.sergeych.lyng.miniast.ParamDoc("tz", type = type("lyng.Any"))),
|
||||
returns = type("lyng.DateTime"), moduleName = "lyng.time") {
|
||||
val tz = when (val a = args.list.getOrNull(0)) {
|
||||
is ObjString -> TimeZone.of(a.value)
|
||||
is ObjInt -> UtcOffset(seconds = a.value.toInt()).asTimeZone()
|
||||
else -> raiseIllegalArgument("invalid timezone: $a")
|
||||
}
|
||||
ObjDateTime(thisAs<ObjDateTime>().instant, tz)
|
||||
}
|
||||
addFnDoc("toUTC", "Shortcut to convert this date time to the UTC time zone.", returns = type("lyng.DateTime"), moduleName = "lyng.time") {
|
||||
ObjDateTime(thisAs<ObjDateTime>().instant, TimeZone.UTC)
|
||||
}
|
||||
|
||||
addFnDoc("addMonths", "Return a new DateTime with the specified number of months added (or subtracted if negative). " +
|
||||
"Normalizes the day of month if necessary (e.g., Jan 31 + 1 month = Feb 28/29).",
|
||||
params = listOf(net.sergeych.lyng.miniast.ParamDoc("months", type = type("lyng.Int"))),
|
||||
returns = type("lyng.DateTime"), moduleName = "lyng.time") {
|
||||
val n = args.list.getOrNull(0)?.toInt() ?: 0
|
||||
val res = thisAs<ObjDateTime>().instant.plus(n, DateTimeUnit.MONTH, thisAs<ObjDateTime>().timeZone)
|
||||
ObjDateTime(res, thisAs<ObjDateTime>().timeZone)
|
||||
}
|
||||
addFnDoc("addYears", "Return a new DateTime with the specified number of years added (or subtracted if negative).",
|
||||
params = listOf(net.sergeych.lyng.miniast.ParamDoc("years", type = type("lyng.Int"))),
|
||||
returns = type("lyng.DateTime"), moduleName = "lyng.time") {
|
||||
val n = args.list.getOrNull(0)?.toInt() ?: 0
|
||||
val res = thisAs<ObjDateTime>().instant.plus(n, DateTimeUnit.YEAR, thisAs<ObjDateTime>().timeZone)
|
||||
ObjDateTime(res, thisAs<ObjDateTime>().timeZone)
|
||||
}
|
||||
|
||||
addClassFn("now") {
|
||||
val tz = when (val a = args.list.getOrNull(0)) {
|
||||
null -> TimeZone.currentSystemDefault()
|
||||
is ObjString -> TimeZone.of(a.value)
|
||||
is ObjInt -> UtcOffset(seconds = a.value.toInt()).asTimeZone()
|
||||
else -> raiseIllegalArgument("invalid timezone: $a")
|
||||
}
|
||||
ObjDateTime(kotlin.time.Clock.System.now(), tz)
|
||||
}
|
||||
|
||||
addClassFnDoc("parseRFC3339",
|
||||
"Parse an RFC3339 string into a DateTime object. " +
|
||||
"Note: if the string does not specify a timezone, UTC is assumed.",
|
||||
params = listOf(net.sergeych.lyng.miniast.ParamDoc("string", type = type("lyng.String"))),
|
||||
returns = type("lyng.DateTime"),
|
||||
moduleName = "lyng.time") {
|
||||
val s = (args.firstAndOnly() as ObjString).value
|
||||
// kotlinx-datetime's Instant.parse handles RFC3339
|
||||
// But we want to preserve the offset if present for DateTime.
|
||||
// However, Instant.parse("...") always gives an Instant.
|
||||
// If we want the specific offset from the string, we might need a more complex parse.
|
||||
// For now, let's stick to parsing it as Instant and converting to UTC or specified TZ.
|
||||
// Actually, if the string has an offset, Instant.parse handles it but returns UTC instant.
|
||||
|
||||
// Let's try to detect if there is an offset in the string.
|
||||
// If not, use UTC.
|
||||
val instant = Instant.parse(s)
|
||||
|
||||
// RFC3339 can have Z or +/-HH:mm or +/-HHmm or +/-HH
|
||||
val tz = try {
|
||||
if (s.endsWith("Z", ignoreCase = true)) {
|
||||
TimeZone.of("Z")
|
||||
} else {
|
||||
// Look for the last + or - which is likely the start of the offset
|
||||
val lastPlus = s.lastIndexOf('+')
|
||||
val lastMinus = s.lastIndexOf('-')
|
||||
val offsetStart = if (lastPlus > lastMinus) lastPlus else lastMinus
|
||||
if (offsetStart > s.lastIndexOf('T')) {
|
||||
// Likely an offset
|
||||
val offsetStr = s.substring(offsetStart)
|
||||
TimeZone.of(offsetStr)
|
||||
} else {
|
||||
TimeZone.UTC
|
||||
}
|
||||
}
|
||||
} catch (e: Exception) {
|
||||
TimeZone.UTC
|
||||
}
|
||||
|
||||
ObjDateTime(instant, tz)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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,6 +20,7 @@ package net.sergeych.lyng.obj
|
||||
import kotlinx.coroutines.Deferred
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.miniast.addFnDoc
|
||||
import net.sergeych.lyng.miniast.addPropertyDoc
|
||||
import net.sergeych.lyng.miniast.type
|
||||
|
||||
open class ObjDeferred(val deferred: Deferred<Obj>): Obj() {
|
||||
@@ -38,28 +39,30 @@ open class ObjDeferred(val deferred: Deferred<Obj>): Obj() {
|
||||
returns = type("lyng.Any"),
|
||||
moduleName = "lyng.stdlib"
|
||||
) { thisAs<ObjDeferred>().deferred.await() }
|
||||
addFnDoc(
|
||||
addPropertyDoc(
|
||||
name = "isCompleted",
|
||||
doc = "Whether this deferred has completed (successfully or with an error).",
|
||||
returns = type("lyng.Bool"),
|
||||
moduleName = "lyng.stdlib"
|
||||
) { thisAs<ObjDeferred>().deferred.isCompleted.toObj() }
|
||||
addFnDoc(
|
||||
type = type("lyng.Bool"),
|
||||
moduleName = "lyng.stdlib",
|
||||
getter = { thisAs<ObjDeferred>().deferred.isCompleted.toObj() }
|
||||
)
|
||||
addPropertyDoc(
|
||||
name = "isActive",
|
||||
doc = "Whether this deferred is currently active (not completed and not cancelled).",
|
||||
returns = type("lyng.Bool"),
|
||||
moduleName = "lyng.stdlib"
|
||||
) {
|
||||
val d = thisAs<ObjDeferred>().deferred
|
||||
(d.isActive || (!d.isCompleted && !d.isCancelled)).toObj()
|
||||
}
|
||||
addFnDoc(
|
||||
type = type("lyng.Bool"),
|
||||
moduleName = "lyng.stdlib",
|
||||
getter = {
|
||||
val d = thisAs<ObjDeferred>().deferred
|
||||
(d.isActive || (!d.isCompleted && !d.isCancelled)).toObj()
|
||||
}
|
||||
)
|
||||
addPropertyDoc(
|
||||
name = "isCancelled",
|
||||
doc = "Whether this deferred was cancelled.",
|
||||
returns = type("lyng.Bool"),
|
||||
moduleName = "lyng.stdlib"
|
||||
) { thisAs<ObjDeferred>().deferred.isCancelled.toObj() }
|
||||
|
||||
type = type("lyng.Bool"),
|
||||
moduleName = "lyng.stdlib",
|
||||
getter = { thisAs<ObjDeferred>().deferred.isCancelled.toObj() }
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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,7 @@
|
||||
package net.sergeych.lyng.obj
|
||||
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.miniast.addFnDoc
|
||||
import net.sergeych.lyng.miniast.addPropertyDoc
|
||||
import net.sergeych.lyng.miniast.type
|
||||
import kotlin.time.Duration
|
||||
import kotlin.time.Duration.Companion.days
|
||||
@@ -74,169 +74,195 @@ class ObjDuration(val duration: Duration) : Obj() {
|
||||
)
|
||||
}
|
||||
}.apply {
|
||||
addFnDoc(
|
||||
addPropertyDoc(
|
||||
name = "days",
|
||||
doc = "Return this duration as a real number of days.",
|
||||
returns = type("lyng.Real"),
|
||||
moduleName = "lyng.time"
|
||||
) { thisAs<ObjDuration>().duration.toDouble(DurationUnit.DAYS).toObj() }
|
||||
addFnDoc(
|
||||
type = type("lyng.Real"),
|
||||
moduleName = "lyng.time",
|
||||
getter = { thisAs<ObjDuration>().duration.toDouble(DurationUnit.DAYS).toObj() }
|
||||
)
|
||||
addPropertyDoc(
|
||||
name = "hours",
|
||||
doc = "Return this duration as a real number of hours.",
|
||||
returns = type("lyng.Real"),
|
||||
moduleName = "lyng.time"
|
||||
) { thisAs<ObjDuration>().duration.toDouble(DurationUnit.HOURS).toObj() }
|
||||
addFnDoc(
|
||||
type = type("lyng.Real"),
|
||||
moduleName = "lyng.time",
|
||||
getter = { thisAs<ObjDuration>().duration.toDouble(DurationUnit.HOURS).toObj() }
|
||||
)
|
||||
addPropertyDoc(
|
||||
name = "minutes",
|
||||
doc = "Return this duration as a real number of minutes.",
|
||||
returns = type("lyng.Real"),
|
||||
moduleName = "lyng.time"
|
||||
) { thisAs<ObjDuration>().duration.toDouble(DurationUnit.MINUTES).toObj() }
|
||||
addFnDoc(
|
||||
type = type("lyng.Real"),
|
||||
moduleName = "lyng.time",
|
||||
getter = { thisAs<ObjDuration>().duration.toDouble(DurationUnit.MINUTES).toObj() }
|
||||
)
|
||||
addPropertyDoc(
|
||||
name = "seconds",
|
||||
doc = "Return this duration as a real number of seconds.",
|
||||
returns = type("lyng.Real"),
|
||||
moduleName = "lyng.time"
|
||||
) { thisAs<ObjDuration>().duration.toDouble(DurationUnit.SECONDS).toObj() }
|
||||
addFnDoc(
|
||||
type = type("lyng.Real"),
|
||||
moduleName = "lyng.time",
|
||||
getter = { thisAs<ObjDuration>().duration.toDouble(DurationUnit.SECONDS).toObj() }
|
||||
)
|
||||
addPropertyDoc(
|
||||
name = "milliseconds",
|
||||
doc = "Return this duration as a real number of milliseconds.",
|
||||
returns = type("lyng.Real"),
|
||||
moduleName = "lyng.time"
|
||||
) { thisAs<ObjDuration>().duration.toDouble(DurationUnit.MILLISECONDS).toObj() }
|
||||
addFnDoc(
|
||||
type = type("lyng.Real"),
|
||||
moduleName = "lyng.time",
|
||||
getter = { thisAs<ObjDuration>().duration.toDouble(DurationUnit.MILLISECONDS).toObj() }
|
||||
)
|
||||
addPropertyDoc(
|
||||
name = "microseconds",
|
||||
doc = "Return this duration as a real number of microseconds.",
|
||||
returns = type("lyng.Real"),
|
||||
moduleName = "lyng.time"
|
||||
) { thisAs<ObjDuration>().duration.toDouble(DurationUnit.MICROSECONDS).toObj() }
|
||||
type = type("lyng.Real"),
|
||||
moduleName = "lyng.time",
|
||||
getter = { thisAs<ObjDuration>().duration.toDouble(DurationUnit.MICROSECONDS).toObj() }
|
||||
)
|
||||
// extensions
|
||||
|
||||
ObjInt.type.addFnDoc(
|
||||
ObjInt.type.addPropertyDoc(
|
||||
name = "seconds",
|
||||
doc = "Construct a `Duration` equal to this integer number of seconds.",
|
||||
returns = type("lyng.Duration"),
|
||||
moduleName = "lyng.time"
|
||||
) { ObjDuration(thisAs<ObjInt>().value.seconds) }
|
||||
type = type("lyng.Duration"),
|
||||
moduleName = "lyng.time",
|
||||
getter = { ObjDuration(thisAs<ObjInt>().value.seconds) }
|
||||
)
|
||||
|
||||
ObjInt.type.addFnDoc(
|
||||
ObjInt.type.addPropertyDoc(
|
||||
name = "second",
|
||||
doc = "Construct a `Duration` equal to this integer number of seconds.",
|
||||
returns = type("lyng.Duration"),
|
||||
moduleName = "lyng.time"
|
||||
) { ObjDuration(thisAs<ObjInt>().value.seconds) }
|
||||
ObjInt.type.addFnDoc(
|
||||
type = type("lyng.Duration"),
|
||||
moduleName = "lyng.time",
|
||||
getter = { ObjDuration(thisAs<ObjInt>().value.seconds) }
|
||||
)
|
||||
ObjInt.type.addPropertyDoc(
|
||||
name = "milliseconds",
|
||||
doc = "Construct a `Duration` equal to this integer number of milliseconds.",
|
||||
returns = type("lyng.Duration"),
|
||||
moduleName = "lyng.time"
|
||||
) { ObjDuration(thisAs<ObjInt>().value.milliseconds) }
|
||||
type = type("lyng.Duration"),
|
||||
moduleName = "lyng.time",
|
||||
getter = { ObjDuration(thisAs<ObjInt>().value.milliseconds) }
|
||||
)
|
||||
|
||||
ObjInt.type.addFnDoc(
|
||||
ObjInt.type.addPropertyDoc(
|
||||
name = "millisecond",
|
||||
doc = "Construct a `Duration` equal to this integer number of milliseconds.",
|
||||
returns = type("lyng.Duration"),
|
||||
moduleName = "lyng.time"
|
||||
) { ObjDuration(thisAs<ObjInt>().value.milliseconds) }
|
||||
ObjReal.type.addFnDoc(
|
||||
type = type("lyng.Duration"),
|
||||
moduleName = "lyng.time",
|
||||
getter = { ObjDuration(thisAs<ObjInt>().value.milliseconds) }
|
||||
)
|
||||
ObjReal.type.addPropertyDoc(
|
||||
name = "seconds",
|
||||
doc = "Construct a `Duration` equal to this real number of seconds.",
|
||||
returns = type("lyng.Duration"),
|
||||
moduleName = "lyng.time"
|
||||
) { ObjDuration(thisAs<ObjReal>().value.seconds) }
|
||||
type = type("lyng.Duration"),
|
||||
moduleName = "lyng.time",
|
||||
getter = { ObjDuration(thisAs<ObjReal>().value.seconds) }
|
||||
)
|
||||
|
||||
ObjReal.type.addFnDoc(
|
||||
ObjReal.type.addPropertyDoc(
|
||||
name = "second",
|
||||
doc = "Construct a `Duration` equal to this real number of seconds.",
|
||||
returns = type("lyng.Duration"),
|
||||
moduleName = "lyng.time"
|
||||
) { ObjDuration(thisAs<ObjReal>().value.seconds) }
|
||||
type = type("lyng.Duration"),
|
||||
moduleName = "lyng.time",
|
||||
getter = { ObjDuration(thisAs<ObjReal>().value.seconds) }
|
||||
)
|
||||
|
||||
ObjReal.type.addFnDoc(
|
||||
ObjReal.type.addPropertyDoc(
|
||||
name = "milliseconds",
|
||||
doc = "Construct a `Duration` equal to this real number of milliseconds.",
|
||||
returns = type("lyng.Duration"),
|
||||
moduleName = "lyng.time"
|
||||
) { ObjDuration(thisAs<ObjReal>().value.milliseconds) }
|
||||
ObjReal.type.addFnDoc(
|
||||
type = type("lyng.Duration"),
|
||||
moduleName = "lyng.time",
|
||||
getter = { ObjDuration(thisAs<ObjReal>().value.milliseconds) }
|
||||
)
|
||||
ObjReal.type.addPropertyDoc(
|
||||
name = "millisecond",
|
||||
doc = "Construct a `Duration` equal to this real number of milliseconds.",
|
||||
returns = type("lyng.Duration"),
|
||||
moduleName = "lyng.time"
|
||||
) { ObjDuration(thisAs<ObjReal>().value.milliseconds) }
|
||||
type = type("lyng.Duration"),
|
||||
moduleName = "lyng.time",
|
||||
getter = { ObjDuration(thisAs<ObjReal>().value.milliseconds) }
|
||||
)
|
||||
|
||||
ObjInt.type.addFnDoc(
|
||||
ObjInt.type.addPropertyDoc(
|
||||
name = "minutes",
|
||||
doc = "Construct a `Duration` equal to this integer number of minutes.",
|
||||
returns = type("lyng.Duration"),
|
||||
moduleName = "lyng.time"
|
||||
) { ObjDuration(thisAs<ObjInt>().value.minutes) }
|
||||
ObjReal.type.addFnDoc(
|
||||
type = type("lyng.Duration"),
|
||||
moduleName = "lyng.time",
|
||||
getter = { ObjDuration(thisAs<ObjInt>().value.minutes) }
|
||||
)
|
||||
ObjReal.type.addPropertyDoc(
|
||||
name = "minutes",
|
||||
doc = "Construct a `Duration` equal to this real number of minutes.",
|
||||
returns = type("lyng.Duration"),
|
||||
moduleName = "lyng.time"
|
||||
) { ObjDuration(thisAs<ObjReal>().value.minutes) }
|
||||
ObjInt.type.addFnDoc(
|
||||
type = type("lyng.Duration"),
|
||||
moduleName = "lyng.time",
|
||||
getter = { ObjDuration(thisAs<ObjReal>().value.minutes) }
|
||||
)
|
||||
ObjInt.type.addPropertyDoc(
|
||||
name = "minute",
|
||||
doc = "Construct a `Duration` equal to this integer number of minutes.",
|
||||
returns = type("lyng.Duration"),
|
||||
moduleName = "lyng.time"
|
||||
) { ObjDuration(thisAs<ObjInt>().value.minutes) }
|
||||
ObjReal.type.addFnDoc(
|
||||
type = type("lyng.Duration"),
|
||||
moduleName = "lyng.time",
|
||||
getter = { ObjDuration(thisAs<ObjInt>().value.minutes) }
|
||||
)
|
||||
ObjReal.type.addPropertyDoc(
|
||||
name = "minute",
|
||||
doc = "Construct a `Duration` equal to this real number of minutes.",
|
||||
returns = type("lyng.Duration"),
|
||||
moduleName = "lyng.time"
|
||||
) { ObjDuration(thisAs<ObjReal>().value.minutes) }
|
||||
ObjInt.type.addFnDoc(
|
||||
type = type("lyng.Duration"),
|
||||
moduleName = "lyng.time",
|
||||
getter = { ObjDuration(thisAs<ObjReal>().value.minutes) }
|
||||
)
|
||||
ObjInt.type.addPropertyDoc(
|
||||
name = "hours",
|
||||
doc = "Construct a `Duration` equal to this integer number of hours.",
|
||||
returns = type("lyng.Duration"),
|
||||
moduleName = "lyng.time"
|
||||
) { ObjDuration(thisAs<ObjInt>().value.hours) }
|
||||
ObjReal.type.addFnDoc(
|
||||
type = type("lyng.Duration"),
|
||||
moduleName = "lyng.time",
|
||||
getter = { ObjDuration(thisAs<ObjInt>().value.hours) }
|
||||
)
|
||||
ObjReal.type.addPropertyDoc(
|
||||
name = "hours",
|
||||
doc = "Construct a `Duration` equal to this real number of hours.",
|
||||
returns = type("lyng.Duration"),
|
||||
moduleName = "lyng.time"
|
||||
) { ObjDuration(thisAs<ObjReal>().value.hours) }
|
||||
ObjInt.type.addFnDoc(
|
||||
type = type("lyng.Duration"),
|
||||
moduleName = "lyng.time",
|
||||
getter = { ObjDuration(thisAs<ObjReal>().value.hours) }
|
||||
)
|
||||
ObjInt.type.addPropertyDoc(
|
||||
name = "hour",
|
||||
doc = "Construct a `Duration` equal to this integer number of hours.",
|
||||
returns = type("lyng.Duration"),
|
||||
moduleName = "lyng.time"
|
||||
) { ObjDuration(thisAs<ObjInt>().value.hours) }
|
||||
ObjReal.type.addFnDoc(
|
||||
type = type("lyng.Duration"),
|
||||
moduleName = "lyng.time",
|
||||
getter = { ObjDuration(thisAs<ObjInt>().value.hours) }
|
||||
)
|
||||
ObjReal.type.addPropertyDoc(
|
||||
name = "hour",
|
||||
doc = "Construct a `Duration` equal to this real number of hours.",
|
||||
returns = type("lyng.Duration"),
|
||||
moduleName = "lyng.time"
|
||||
) { ObjDuration(thisAs<ObjReal>().value.hours) }
|
||||
ObjInt.type.addFnDoc(
|
||||
type = type("lyng.Duration"),
|
||||
moduleName = "lyng.time",
|
||||
getter = { ObjDuration(thisAs<ObjReal>().value.hours) }
|
||||
)
|
||||
ObjInt.type.addPropertyDoc(
|
||||
name = "days",
|
||||
doc = "Construct a `Duration` equal to this integer number of days.",
|
||||
returns = type("lyng.Duration"),
|
||||
moduleName = "lyng.time"
|
||||
) { ObjDuration(thisAs<ObjInt>().value.days) }
|
||||
ObjReal.type.addFnDoc(
|
||||
type = type("lyng.Duration"),
|
||||
moduleName = "lyng.time",
|
||||
getter = { ObjDuration(thisAs<ObjInt>().value.days) }
|
||||
)
|
||||
ObjReal.type.addPropertyDoc(
|
||||
name = "days",
|
||||
doc = "Construct a `Duration` equal to this real number of days.",
|
||||
returns = type("lyng.Duration"),
|
||||
moduleName = "lyng.time"
|
||||
) { ObjDuration(thisAs<ObjReal>().value.days) }
|
||||
ObjInt.type.addFnDoc(
|
||||
type = type("lyng.Duration"),
|
||||
moduleName = "lyng.time",
|
||||
getter = { ObjDuration(thisAs<ObjReal>().value.days) }
|
||||
)
|
||||
ObjInt.type.addPropertyDoc(
|
||||
name = "day",
|
||||
doc = "Construct a `Duration` equal to this integer number of days.",
|
||||
returns = type("lyng.Duration"),
|
||||
moduleName = "lyng.time"
|
||||
) { ObjDuration(thisAs<ObjInt>().value.days) }
|
||||
ObjReal.type.addFnDoc(
|
||||
type = type("lyng.Duration"),
|
||||
moduleName = "lyng.time",
|
||||
getter = { ObjDuration(thisAs<ObjInt>().value.days) }
|
||||
)
|
||||
ObjReal.type.addPropertyDoc(
|
||||
name = "day",
|
||||
doc = "Construct a `Duration` equal to this real number of days.",
|
||||
returns = type("lyng.Duration"),
|
||||
moduleName = "lyng.time"
|
||||
) { ObjDuration(thisAs<ObjReal>().value.days) }
|
||||
type = type("lyng.Duration"),
|
||||
moduleName = "lyng.time",
|
||||
getter = { ObjDuration(thisAs<ObjReal>().value.days) }
|
||||
)
|
||||
|
||||
|
||||
// addFn("epochSeconds") {
|
||||
|
||||
@@ -35,6 +35,8 @@ package net.sergeych.lyng.obj/*
|
||||
import kotlinx.serialization.json.JsonElement
|
||||
import kotlinx.serialization.json.JsonPrimitive
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.miniast.addPropertyDoc
|
||||
import net.sergeych.lyng.miniast.type
|
||||
import net.sergeych.lynon.LynonDecoder
|
||||
import net.sergeych.lynon.LynonEncoder
|
||||
import net.sergeych.lynon.LynonType
|
||||
@@ -76,8 +78,8 @@ class ObjEnumClass(val name: String) : ObjClass(name, EnumBase) {
|
||||
val name = requireOnlyArg<ObjString>()
|
||||
byName[name] ?: raiseSymbolNotFound("does not exists: enum ${className}.$name")
|
||||
}
|
||||
addFn("name") { thisAs<ObjEnumEntry>().name }
|
||||
addFn("ordinal") { thisAs<ObjEnumEntry>().ordinal }
|
||||
addPropertyDoc("name", doc = "Entry name as string", type = type("lyng.String"), getter = { thisAs<ObjEnumEntry>().name })
|
||||
addPropertyDoc("ordinal", doc = "Entry ordinal position", type = type("lyng.Int"), getter = { thisAs<ObjEnumEntry>().ordinal })
|
||||
|
||||
}
|
||||
|
||||
|
||||
@@ -17,11 +17,10 @@
|
||||
|
||||
package net.sergeych.lyng.obj
|
||||
|
||||
import net.sergeych.bintools.encodeToHex
|
||||
import net.sergeych.lyng.*
|
||||
import net.sergeych.lyng.miniast.TypeGenericDoc
|
||||
import net.sergeych.lyng.miniast.addConstDoc
|
||||
import net.sergeych.lyng.miniast.addFnDoc
|
||||
import net.sergeych.lyng.miniast.addPropertyDoc
|
||||
import net.sergeych.lyng.miniast.type
|
||||
import net.sergeych.lynon.LynonDecoder
|
||||
import net.sergeych.lynon.LynonEncoder
|
||||
@@ -73,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)")
|
||||
@@ -101,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
|
||||
}
|
||||
@@ -130,10 +132,12 @@ 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 = "ExceptionClass[$name]@${hashCode().encodeToHex()}"
|
||||
override fun toString(): String = name
|
||||
|
||||
override suspend fun deserialize(scope: Scope, decoder: LynonDecoder, lynonType: LynonType?): Obj {
|
||||
return try {
|
||||
@@ -170,43 +174,44 @@ open class ObjException(
|
||||
ObjVoid
|
||||
})
|
||||
instanceConstructor = statement { ObjVoid }
|
||||
addConstDoc(
|
||||
addPropertyDoc(
|
||||
name = "message",
|
||||
value = statement {
|
||||
when (val t = thisObj) {
|
||||
doc = "Human‑readable error message.",
|
||||
type = type("lyng.String"),
|
||||
moduleName = "lyng.stdlib",
|
||||
getter = {
|
||||
when (val t = this.thisObj) {
|
||||
is ObjException -> t.message
|
||||
is ObjInstance -> t.instanceScope.get("Exception::message")?.value ?: ObjNull
|
||||
else -> ObjNull
|
||||
}
|
||||
},
|
||||
doc = "Human‑readable error message.",
|
||||
type = type("lyng.String"),
|
||||
moduleName = "lyng.stdlib"
|
||||
}
|
||||
)
|
||||
addConstDoc(
|
||||
addPropertyDoc(
|
||||
name = "extraData",
|
||||
value = statement {
|
||||
when (val t = thisObj) {
|
||||
doc = "Extra data associated with the exception.",
|
||||
type = type("lyng.Any", nullable = true),
|
||||
moduleName = "lyng.stdlib",
|
||||
getter = {
|
||||
when (val t = this.thisObj) {
|
||||
is ObjException -> t.extraData
|
||||
else -> ObjNull
|
||||
}
|
||||
},
|
||||
doc = "Extra data associated with the exception.",
|
||||
type = type("lyng.Any", nullable = true),
|
||||
moduleName = "lyng.stdlib"
|
||||
}
|
||||
)
|
||||
addFnDoc(
|
||||
addPropertyDoc(
|
||||
name = "stackTrace",
|
||||
doc = "Stack trace captured at throw site as a list of `StackTraceEntry`.",
|
||||
returns = TypeGenericDoc(type("lyng.List"), listOf(type("lyng.StackTraceEntry"))),
|
||||
moduleName = "lyng.stdlib"
|
||||
) {
|
||||
when (val t = thisObj) {
|
||||
is ObjException -> t.getStackTrace()
|
||||
is ObjInstance -> t.instanceScope.get("Exception::stackTrace")?.value as? ObjList ?: ObjList()
|
||||
else -> ObjList()
|
||||
type = TypeGenericDoc(type("lyng.List"), listOf(type("lyng.StackTraceEntry"))),
|
||||
moduleName = "lyng.stdlib",
|
||||
getter = {
|
||||
when (val t = this.thisObj) {
|
||||
is ObjException -> t.getStackTrace()
|
||||
is ObjInstance -> t.instanceScope.get("Exception::stackTrace")?.value as? ObjList ?: ObjList()
|
||||
else -> ObjList()
|
||||
}
|
||||
}
|
||||
}
|
||||
)
|
||||
addFnDoc(
|
||||
name = "toString",
|
||||
doc = "Human‑readable string representation of the error.",
|
||||
@@ -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)
|
||||
|
||||
@@ -21,6 +21,7 @@ import kotlinx.serialization.json.JsonElement
|
||||
import kotlinx.serialization.json.JsonObject
|
||||
import net.sergeych.lyng.Arguments
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.Visibility
|
||||
import net.sergeych.lyng.canAccessMember
|
||||
import net.sergeych.lynon.LynonDecoder
|
||||
import net.sergeych.lynon.LynonEncoder
|
||||
@@ -31,50 +32,54 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
|
||||
internal lateinit var instanceScope: Scope
|
||||
|
||||
override suspend fun readField(scope: Scope, name: String): ObjRecord {
|
||||
// 1. Direct (unmangled) lookup first
|
||||
instanceScope[name]?.let { rec ->
|
||||
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
|
||||
c.members[name]?.let { rec ->
|
||||
if (rec.visibility == Visibility.Private) {
|
||||
return resolveRecord(scope, rec, name, c)
|
||||
}
|
||||
}
|
||||
// Check for private fields (stored in instanceScope)
|
||||
val mangled = c.mangledName(name)
|
||||
instanceScope.objects[mangled]?.let { rec ->
|
||||
if (rec.visibility == Visibility.Private) {
|
||||
return resolveRecord(scope, rec, name, c)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 1. MRO mangled storage
|
||||
for (cls in objClass.mro) {
|
||||
if (cls.className == "Obj") break
|
||||
val mangled = cls.mangledName(name)
|
||||
instanceScope.objects[mangled]?.let { rec ->
|
||||
if (canAccessMember(rec.visibility, cls, caller, name)) {
|
||||
return resolveRecord(scope, rec, name, cls)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 2. Unmangled storage
|
||||
instanceScope.objects[name]?.let { rec ->
|
||||
val decl = rec.declaringClass
|
||||
// Allow unconditional access when accessing through `this` of the same instance
|
||||
// BUT only if we are in the class context (not extension)
|
||||
if (scope.thisObj !== this || scope.currentClassCtx == null) {
|
||||
val caller = scope.currentClassCtx
|
||||
if (!canAccessMember(rec.visibility, decl, caller))
|
||||
scope.raiseError(
|
||||
ObjIllegalAccessException(
|
||||
scope,
|
||||
"can't access field $name (declared in ${decl?.className ?: "?"})"
|
||||
)
|
||||
)
|
||||
if (canAccessMember(rec.visibility, decl, caller, name)) {
|
||||
return resolveRecord(scope, rec, name, decl)
|
||||
}
|
||||
return resolveRecord(scope, rec, name, decl)
|
||||
}
|
||||
|
||||
// 2. MI-mangled instance scope lookup
|
||||
val cls = objClass
|
||||
fun findMangledInRead(): ObjRecord? {
|
||||
instanceScope.objects["${cls.className}::$name"]?.let { return it }
|
||||
for (p in cls.mroParents) {
|
||||
instanceScope.objects["${p.className}::$name"]?.let { return it }
|
||||
}
|
||||
return null
|
||||
}
|
||||
|
||||
findMangledInRead()?.let { rec ->
|
||||
val declaring = when {
|
||||
instanceScope.objects.containsKey("${cls.className}::$name") -> cls
|
||||
else -> cls.mroParents.firstOrNull { instanceScope.objects.containsKey("${it.className}::$name") }
|
||||
}
|
||||
if (scope.thisObj !== this || scope.currentClassCtx == null) {
|
||||
val caller = scope.currentClassCtx
|
||||
if (!canAccessMember(rec.visibility, declaring, caller))
|
||||
scope.raiseError(
|
||||
ObjIllegalAccessException(
|
||||
scope,
|
||||
"can't access field $name (declared in ${declaring?.className ?: "?"})"
|
||||
)
|
||||
)
|
||||
}
|
||||
return resolveRecord(scope, rec, name, declaring)
|
||||
}
|
||||
|
||||
// 3. Fall back to super (handles class members and extensions)
|
||||
@@ -82,7 +87,118 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
|
||||
}
|
||||
|
||||
override suspend fun resolveRecord(scope: Scope, obj: ObjRecord, name: String, decl: ObjClass?): ObjRecord {
|
||||
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?.mangledName(name) ?: name
|
||||
var del = instanceScope[storageName]?.delegate ?: obj.delegate
|
||||
if (del == null) {
|
||||
for (c in objClass.mro) {
|
||||
del = instanceScope[c.mangledName(name)]?.delegate
|
||||
if (del != null) break
|
||||
}
|
||||
}
|
||||
del = del ?: scope.raiseError("Internal error: delegated property $name has no delegate")
|
||||
val res = del.invokeInstanceMethod(scope, "getValue", Arguments(this, ObjString(name)))
|
||||
obj.value = res
|
||||
return obj
|
||||
}
|
||||
|
||||
// Map member template to instance storage if applicable
|
||||
var targetRec = obj
|
||||
val d = decl ?: obj.declaringClass
|
||||
if (d != null) {
|
||||
val mangled = d.mangledName(name)
|
||||
instanceScope.objects[mangled]?.let {
|
||||
targetRec = it
|
||||
}
|
||||
}
|
||||
if (targetRec === obj) {
|
||||
instanceScope.objects[name]?.let { rec ->
|
||||
// Check if this record in instanceScope is the one we want.
|
||||
// For members, it must match the declaring class.
|
||||
// Arguments are also preferred.
|
||||
if (rec.type == ObjRecord.Type.Argument || rec.declaringClass == d || rec.declaringClass == null) {
|
||||
targetRec = rec
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return super.resolveRecord(scope, targetRec, name, d)
|
||||
}
|
||||
|
||||
override suspend fun writeField(scope: Scope, name: String, newValue: 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
|
||||
c.members[name]?.let { rec ->
|
||||
if (rec.visibility == Visibility.Private) {
|
||||
updateRecord(scope, resolveRecord(scope, rec, name, c), name, newValue, c)
|
||||
return
|
||||
}
|
||||
}
|
||||
// Check for private fields (stored in instanceScope)
|
||||
val mangled = c.mangledName(name)
|
||||
instanceScope.objects[mangled]?.let { rec ->
|
||||
if (rec.visibility == Visibility.Private) {
|
||||
updateRecord(scope, rec, name, newValue, c)
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 1. MRO mangled storage
|
||||
for (cls in objClass.mro) {
|
||||
if (cls.className == "Obj") break
|
||||
val mangled = cls.mangledName(name)
|
||||
instanceScope.objects[mangled]?.let { rec ->
|
||||
if (canAccessMember(rec.effectiveWriteVisibility, cls, caller, name)) {
|
||||
updateRecord(scope, rec, name, newValue, cls)
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 2. Unmangled storage
|
||||
instanceScope.objects[name]?.let { rec ->
|
||||
val decl = rec.declaringClass
|
||||
if (canAccessMember(rec.effectiveWriteVisibility, decl, caller, name)) {
|
||||
updateRecord(scope, rec, name, newValue, decl)
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
super.writeField(scope, name, newValue)
|
||||
}
|
||||
|
||||
private suspend fun updateRecord(scope: Scope, rec: ObjRecord, name: String, newValue: Obj, decl: ObjClass?) {
|
||||
if (rec.type == ObjRecord.Type.Property) {
|
||||
val prop = rec.value as ObjProperty
|
||||
prop.callSetter(scope, this, newValue, decl)
|
||||
return
|
||||
}
|
||||
if (rec.type == ObjRecord.Type.Delegated) {
|
||||
val storageName = "${decl?.className}::$name"
|
||||
var del = instanceScope[storageName]?.delegate
|
||||
if (del == null) {
|
||||
@@ -91,136 +207,98 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
|
||||
if (del != null) break
|
||||
}
|
||||
}
|
||||
del = del ?: obj.delegate ?: scope.raiseError("Internal error: delegated property $name has no delegate (tried $storageName)")
|
||||
val res = del.invokeInstanceMethod(scope, "getValue", Arguments(this, ObjString(name)))
|
||||
obj.value = res
|
||||
return obj
|
||||
}
|
||||
return super.resolveRecord(scope, obj, name, decl)
|
||||
}
|
||||
|
||||
override suspend fun writeField(scope: Scope, name: String, newValue: Obj) {
|
||||
// Direct (unmangled) first
|
||||
instanceScope[name]?.let { f ->
|
||||
val decl = f.declaringClass
|
||||
if (scope.thisObj !== this || scope.currentClassCtx == null) {
|
||||
val caller = scope.currentClassCtx
|
||||
if (!canAccessMember(f.effectiveWriteVisibility, decl, caller))
|
||||
ObjIllegalAccessException(
|
||||
scope,
|
||||
"can't assign to field $name (declared in ${decl?.className ?: "?"})"
|
||||
).raise()
|
||||
}
|
||||
if (f.type == ObjRecord.Type.Property) {
|
||||
val prop = f.value as ObjProperty
|
||||
prop.callSetter(scope, this, newValue, decl)
|
||||
return
|
||||
}
|
||||
if (f.type == ObjRecord.Type.Delegated) {
|
||||
val storageName = "${decl?.className}::$name"
|
||||
var del = instanceScope[storageName]?.delegate
|
||||
if (del == null) {
|
||||
for (c in objClass.mro) {
|
||||
del = instanceScope["${c.className}::$name"]?.delegate
|
||||
if (del != null) break
|
||||
}
|
||||
}
|
||||
del = del ?: f.delegate ?: scope.raiseError("Internal error: delegated property $name has no delegate (tried $storageName)")
|
||||
del.invokeInstanceMethod(scope, "setValue", Arguments(this, ObjString(name), newValue))
|
||||
return
|
||||
}
|
||||
if (!f.isMutable && f.value !== ObjUnset) ObjIllegalAssignmentException(scope, "can't reassign val $name").raise()
|
||||
if (f.value.assign(scope, newValue) == null)
|
||||
f.value = newValue
|
||||
del = del ?: rec.delegate ?: scope.raiseError("Internal error: delegated property $name has no delegate (tried $storageName)")
|
||||
del.invokeInstanceMethod(scope, "setValue", Arguments(this, ObjString(name), newValue))
|
||||
return
|
||||
}
|
||||
// Try MI-mangled resolution along linearization (C3 MRO)
|
||||
val cls = objClass
|
||||
fun findMangled(): ObjRecord? {
|
||||
instanceScope.objects["${cls.className}::$name"]?.let { return it }
|
||||
for (p in cls.mroParents) {
|
||||
instanceScope.objects["${p.className}::$name"]?.let { return it }
|
||||
}
|
||||
return null
|
||||
}
|
||||
|
||||
val rec = findMangled()
|
||||
if (rec != null) {
|
||||
val declaring = when {
|
||||
instanceScope.objects.containsKey("${cls.className}::$name") -> cls
|
||||
else -> cls.mroParents.firstOrNull { instanceScope.objects.containsKey("${it.className}::$name") }
|
||||
}
|
||||
if (scope.thisObj !== this || scope.currentClassCtx == null) {
|
||||
val caller = scope.currentClassCtx
|
||||
if (!canAccessMember(rec.effectiveWriteVisibility, declaring, caller))
|
||||
ObjIllegalAccessException(
|
||||
scope,
|
||||
"can't assign to field $name (declared in ${declaring?.className ?: "?"})"
|
||||
).raise()
|
||||
}
|
||||
if (rec.type == ObjRecord.Type.Property) {
|
||||
val prop = rec.value as ObjProperty
|
||||
prop.callSetter(scope, this, newValue, declaring)
|
||||
return
|
||||
}
|
||||
if (rec.type == ObjRecord.Type.Delegated) {
|
||||
val storageName = "${declaring?.className}::$name"
|
||||
var del = instanceScope[storageName]?.delegate
|
||||
if (del == null) {
|
||||
for (c in objClass.mro) {
|
||||
del = instanceScope["${c.className}::$name"]?.delegate
|
||||
if (del != null) break
|
||||
}
|
||||
}
|
||||
del = del ?: rec.delegate ?: scope.raiseError("Internal error: delegated property $name has no delegate (tried $storageName)")
|
||||
del.invokeInstanceMethod(scope, "setValue", Arguments(this, ObjString(name), newValue))
|
||||
return
|
||||
}
|
||||
if (!rec.isMutable && rec.value !== ObjUnset) ObjIllegalAssignmentException(scope, "can't reassign val $name").raise()
|
||||
if (rec.value.assign(scope, newValue) == null)
|
||||
rec.value = newValue
|
||||
return
|
||||
}
|
||||
super.writeField(scope, name, newValue)
|
||||
if (!rec.isMutable && rec.value !== ObjUnset) ObjIllegalAssignmentException(scope, "can't reassign val $name").raise()
|
||||
if (rec.value.assign(scope, newValue) == null)
|
||||
rec.value = newValue
|
||||
}
|
||||
|
||||
override suspend fun invokeInstanceMethod(
|
||||
scope: Scope, name: String, args: Arguments,
|
||||
onNotFoundResult: (suspend () -> Obj?)?
|
||||
): Obj {
|
||||
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)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 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, c)
|
||||
} else if (rec.type == ObjRecord.Type.Fun) {
|
||||
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)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 1. Walk MRO to find member, handling delegation
|
||||
for (cls in objClass.mro) {
|
||||
if (cls.className == "Obj") break
|
||||
val rec = cls.members[name] ?: cls.classScope?.objects?.get(name)
|
||||
if (rec != null) {
|
||||
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)")
|
||||
|
||||
// For delegated member, try 'invoke' first if it's a function-like call
|
||||
val allArgs = (listOf(this, ObjString(name)) + args.list).toTypedArray()
|
||||
return del.invokeInstanceMethod(scope, "invoke", Arguments(*allArgs), onNotFoundResult = {
|
||||
// Fallback: property delegation
|
||||
// Fallback: property delegation (getValue then call result)
|
||||
val propVal = del.invokeInstanceMethod(scope, "getValue", Arguments(this, ObjString(name)))
|
||||
propVal.invoke(scope, this, args, rec.declaringClass ?: cls)
|
||||
})
|
||||
}
|
||||
if (rec.type == ObjRecord.Type.Fun && !rec.isAbstract) {
|
||||
val decl = rec.declaringClass ?: cls
|
||||
val caller = scope.currentClassCtx ?: if (scope.thisObj === this) objClass else null
|
||||
if (!canAccessMember(rec.visibility, decl, caller))
|
||||
scope.raiseError(
|
||||
ObjIllegalAccessException(
|
||||
scope,
|
||||
"can't invoke method $name (declared in ${decl.className})"
|
||||
)
|
||||
val decl = rec.declaringClass ?: cls
|
||||
val effectiveCaller = caller ?: if (scope.thisObj === this) objClass else null
|
||||
if (!canAccessMember(rec.visibility, decl, effectiveCaller, name))
|
||||
scope.raiseError(
|
||||
ObjIllegalAccessException(
|
||||
scope,
|
||||
"can't invoke method $name (declared in ${decl.className})"
|
||||
)
|
||||
)
|
||||
|
||||
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
|
||||
)
|
||||
} else if ((rec.type == ObjRecord.Type.Field || rec.type == ObjRecord.Type.Property) && !rec.isAbstract) {
|
||||
} else if (rec.type == ObjRecord.Type.Field || rec.type == ObjRecord.Type.ConstructorField || rec.type == ObjRecord.Type.Argument) {
|
||||
val resolved = readField(scope, name)
|
||||
return resolved.value.invoke(scope, this, args, resolved.declaringClass)
|
||||
}
|
||||
@@ -260,7 +338,7 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
|
||||
// values, so we save size of the construction:
|
||||
|
||||
// using objlist allow for some optimizations:
|
||||
val params = meta.params.map { readField(scope, it.name).value }
|
||||
val params = meta.params.filter { !it.isTransient }.map { readField(scope, it.name).value }
|
||||
encoder.encodeAnyList(scope, params)
|
||||
val vars = serializingVars.values.map { it.value }
|
||||
if (vars.isNotEmpty()) {
|
||||
@@ -279,8 +357,10 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
|
||||
val result = mutableMapOf<String, JsonElement>()
|
||||
val meta = objClass.constructorMeta
|
||||
?: scope.raiseError("can't serialize non-serializable object (no constructor meta)")
|
||||
for (entry in meta.params)
|
||||
result[entry.name] = readField(scope, entry.name).value.toJson(scope)
|
||||
for (entry in meta.params) {
|
||||
if (!entry.isTransient)
|
||||
result[entry.name] = readField(scope, entry.name).value.toJson(scope)
|
||||
}
|
||||
for (i in serializingVars) {
|
||||
// remove T:: prefix from the field name for JSON
|
||||
val parts = i.key.split("::")
|
||||
@@ -299,7 +379,8 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
|
||||
it.value.type.serializable &&
|
||||
it.value.type == ObjRecord.Type.Field &&
|
||||
it.value.isMutable &&
|
||||
!metaParams.contains(it.key)
|
||||
!metaParams.contains(it.key) &&
|
||||
!it.value.isTransient
|
||||
}
|
||||
}
|
||||
|
||||
@@ -308,7 +389,10 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
|
||||
if (localVars.isNotEmpty()) {
|
||||
val vars = decoder.decodeAnyList(scope)
|
||||
if (vars.size > serializingVars.size)
|
||||
scope.raiseIllegalArgument("serialized vars has bigger size than instance vars")
|
||||
scope.raiseIllegalArgument(
|
||||
"serialized vars has bigger size ${vars.size} than instance vars (${serializingVars.size}): "+
|
||||
vars.joinToString(",")
|
||||
)
|
||||
for ((i, v) in vars.withIndex()) {
|
||||
localVars[i].value = v
|
||||
}
|
||||
@@ -317,7 +401,7 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
|
||||
|
||||
protected val comparableVars: Map<String, ObjRecord> by lazy {
|
||||
instanceScope.objects.filter {
|
||||
it.value.type.comparable && (it.value.type != ObjRecord.Type.Field || it.value.isMutable)
|
||||
it.value.type.comparable && (it.value.type != ObjRecord.Type.Field || it.value.isMutable) && !it.value.isTransient
|
||||
}
|
||||
}
|
||||
|
||||
@@ -326,7 +410,7 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
|
||||
if (other.objClass != objClass) return -1
|
||||
for (f in comparableVars) {
|
||||
val a = f.value.value
|
||||
val b = other.instanceScope[f.key]!!.value
|
||||
val b = other.instanceScope.objects[f.key]?.value ?: scope.raiseError("Internal error: field ${f.key} not found in other instance")
|
||||
val d = a.compareTo(scope, b)
|
||||
if (d != 0) return d
|
||||
}
|
||||
@@ -351,33 +435,33 @@ class ObjQualifiedView(val instance: ObjInstance, private val startClass: ObjCla
|
||||
// Visibility: declaring class is the qualified ancestor for mangled storage
|
||||
val decl = rec.declaringClass ?: startClass
|
||||
val caller = scope.currentClassCtx
|
||||
if (!canAccessMember(rec.visibility, decl, caller))
|
||||
if (!canAccessMember(rec.visibility, decl, caller, name))
|
||||
scope.raiseError(ObjIllegalAccessException(scope, "can't access field $name (declared in ${decl.className})"))
|
||||
return resolveRecord(scope, rec, name, decl)
|
||||
return instance.resolveRecord(scope, rec, name, decl)
|
||||
}
|
||||
// Then try instance locals (unmangled) only if startClass is the dynamic class itself
|
||||
if (startClass === instance.objClass) {
|
||||
instance.instanceScope[name]?.let { rec ->
|
||||
val decl = rec.declaringClass ?: instance.objClass.findDeclaringClassOf(name)
|
||||
val caller = scope.currentClassCtx
|
||||
if (!canAccessMember(rec.visibility, decl, caller))
|
||||
if (!canAccessMember(rec.visibility, decl, caller, name))
|
||||
scope.raiseError(
|
||||
ObjIllegalAccessException(
|
||||
scope,
|
||||
"can't access field $name (declared in ${decl?.className ?: "?"})"
|
||||
)
|
||||
)
|
||||
return resolveRecord(scope, rec, name, decl)
|
||||
return instance.resolveRecord(scope, rec, name, decl)
|
||||
}
|
||||
}
|
||||
// Finally try methods/properties starting from ancestor
|
||||
val r = memberFromAncestor(name) ?: scope.raiseError("no such field: $name")
|
||||
val decl = r.declaringClass ?: startClass
|
||||
val caller = scope.currentClassCtx
|
||||
if (!canAccessMember(r.visibility, decl, caller))
|
||||
if (!canAccessMember(r.visibility, decl, caller, name))
|
||||
scope.raiseError(ObjIllegalAccessException(scope, "can't access field $name (declared in ${decl.className})"))
|
||||
|
||||
return resolveRecord(scope, r, name, decl)
|
||||
return instance.resolveRecord(scope, r, name, decl)
|
||||
}
|
||||
|
||||
override suspend fun writeField(scope: Scope, name: String, newValue: Obj) {
|
||||
@@ -386,7 +470,7 @@ class ObjQualifiedView(val instance: ObjInstance, private val startClass: ObjCla
|
||||
instance.instanceScope.objects[mangled]?.let { f ->
|
||||
val decl = f.declaringClass ?: startClass
|
||||
val caller = scope.currentClassCtx
|
||||
if (!canAccessMember(f.effectiveWriteVisibility, decl, caller))
|
||||
if (!canAccessMember(f.effectiveWriteVisibility, decl, caller, name))
|
||||
ObjIllegalAccessException(
|
||||
scope,
|
||||
"can't assign to field $name (declared in ${decl.className})"
|
||||
@@ -400,7 +484,7 @@ class ObjQualifiedView(val instance: ObjInstance, private val startClass: ObjCla
|
||||
instance.instanceScope[name]?.let { f ->
|
||||
val decl = f.declaringClass ?: instance.objClass.findDeclaringClassOf(name)
|
||||
val caller = scope.currentClassCtx
|
||||
if (!canAccessMember(f.effectiveWriteVisibility, decl, caller))
|
||||
if (!canAccessMember(f.effectiveWriteVisibility, decl, caller, name))
|
||||
ObjIllegalAccessException(
|
||||
scope,
|
||||
"can't assign to field $name (declared in ${decl?.className ?: "?"})"
|
||||
@@ -413,7 +497,7 @@ class ObjQualifiedView(val instance: ObjInstance, private val startClass: ObjCla
|
||||
val r = memberFromAncestor(name) ?: scope.raiseError("no such field: $name")
|
||||
val decl = r.declaringClass ?: startClass
|
||||
val caller = scope.currentClassCtx
|
||||
if (!canAccessMember(r.effectiveWriteVisibility, decl, caller))
|
||||
if (!canAccessMember(r.effectiveWriteVisibility, decl, caller, name))
|
||||
ObjIllegalAccessException(scope, "can't assign to field $name (declared in ${decl.className})").raise()
|
||||
if (!r.isMutable) scope.raiseError("can't assign to read-only field: $name")
|
||||
if (r.value.assign(scope, newValue) == null) r.value = newValue
|
||||
@@ -429,7 +513,7 @@ class ObjQualifiedView(val instance: ObjInstance, private val startClass: ObjCla
|
||||
memberFromAncestor(name)?.let { rec ->
|
||||
val decl = rec.declaringClass ?: startClass
|
||||
val caller = scope.currentClassCtx
|
||||
if (!canAccessMember(rec.visibility, decl, caller))
|
||||
if (!canAccessMember(rec.visibility, decl, caller, name))
|
||||
scope.raiseError(ObjIllegalAccessException(scope, "can't invoke method $name (declared in ${decl.className})"))
|
||||
val saved = instance.instanceScope.currentClassCtx
|
||||
instance.instanceScope.currentClassCtx = decl
|
||||
@@ -444,7 +528,7 @@ class ObjQualifiedView(val instance: ObjInstance, private val startClass: ObjCla
|
||||
instance.instanceScope[name]?.let { rec ->
|
||||
val decl = rec.declaringClass ?: instance.objClass.findDeclaringClassOf(name)
|
||||
val caller = scope.currentClassCtx
|
||||
if (!canAccessMember(rec.visibility, decl, caller))
|
||||
if (!canAccessMember(rec.visibility, decl, caller, name))
|
||||
scope.raiseError(
|
||||
ObjIllegalAccessException(
|
||||
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.
|
||||
@@ -28,13 +28,26 @@ import net.sergeych.lynon.LynonType
|
||||
class ObjInstanceClass(val name: String, vararg parents: ObjClass) : ObjClass(name, *parents) {
|
||||
|
||||
override suspend fun deserialize(scope: Scope, decoder: LynonDecoder, lynonType: LynonType?): Obj {
|
||||
val args = decoder.decodeAnyList(scope)
|
||||
val actualSize = constructorMeta?.params?.size ?: 0
|
||||
if (args.size > actualSize)
|
||||
scope.raiseIllegalArgument("constructor $name has only $actualSize but serialized version has ${args.size}")
|
||||
val newScope = scope.createChildScope(args = Arguments(args))
|
||||
val instance = createInstance(newScope)
|
||||
initializeInstance(instance, newScope.args, runConstructors = false)
|
||||
val serializedArgs = decoder.decodeAnyList(scope)
|
||||
val meta = constructorMeta ?: scope.raiseError("no constructor meta for $name")
|
||||
val nonTransientCount = meta.params.count { !it.isTransient }
|
||||
if (serializedArgs.size != nonTransientCount)
|
||||
scope.raiseIllegalArgument("constructor $name expects $nonTransientCount non-transient arguments, but serialized version has ${serializedArgs.size}")
|
||||
|
||||
var sIdx = 0
|
||||
val namedArgs = mutableMapOf<String, Obj>()
|
||||
for (p in meta.params) {
|
||||
if (!p.isTransient) {
|
||||
namedArgs[p.name] = serializedArgs[sIdx++]
|
||||
} else if (p.defaultValue == null) {
|
||||
// If transient parameter has no default value, we use ObjNull to avoid "too few arguments" error
|
||||
namedArgs[p.name] = ObjNull
|
||||
}
|
||||
}
|
||||
// Using named arguments allows the constructor to apply default values for transient parameters
|
||||
val newArgs = Arguments(list = emptyList<Obj>(), named = namedArgs)
|
||||
val instance = createInstance(scope.createChildScope(args = newArgs))
|
||||
initializeInstance(instance, newArgs, runConstructors = false)
|
||||
return instance.apply {
|
||||
deserializeStateVars(scope, decoder)
|
||||
invokeInstanceMethod(scope, "onDeserialized") { ObjVoid }
|
||||
|
||||
@@ -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.
|
||||
@@ -17,15 +17,18 @@
|
||||
|
||||
package net.sergeych.lyng.obj
|
||||
|
||||
import kotlinx.datetime.*
|
||||
import kotlinx.serialization.json.JsonElement
|
||||
import kotlinx.serialization.json.JsonPrimitive
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.miniast.addFnDoc
|
||||
import net.sergeych.lyng.miniast.addPropertyDoc
|
||||
import net.sergeych.lyng.miniast.type
|
||||
import net.sergeych.lynon.LynonDecoder
|
||||
import net.sergeych.lynon.LynonEncoder
|
||||
import net.sergeych.lynon.LynonSettings
|
||||
import net.sergeych.lynon.LynonType
|
||||
import kotlin.time.Clock
|
||||
import kotlin.time.Instant
|
||||
import kotlin.time.isDistantFuture
|
||||
import kotlin.time.isDistantPast
|
||||
|
||||
@@ -119,6 +122,7 @@ class ObjInstant(val instant: Instant,val truncateMode: LynonSettings.InstantTru
|
||||
val nanos = (a0.value - seconds) * 1e9
|
||||
Instant.fromEpochSeconds(seconds, nanos.toLong())
|
||||
}
|
||||
is ObjString -> Instant.parse(a0.value)
|
||||
is ObjInstant -> a0.instant
|
||||
|
||||
else -> {
|
||||
@@ -148,40 +152,126 @@ class ObjInstant(val instant: Instant,val truncateMode: LynonSettings.InstantTru
|
||||
}
|
||||
|
||||
}.apply {
|
||||
addFn("epochSeconds") {
|
||||
val instant = thisAs<ObjInstant>().instant
|
||||
ObjReal(instant.epochSeconds + instant.nanosecondsOfSecond * 1e-9)
|
||||
addPropertyDoc(
|
||||
name = "epochSeconds",
|
||||
doc = "Return the number of seconds since the Unix epoch as a real number (including fractions).",
|
||||
type = type("lyng.Real"),
|
||||
moduleName = "lyng.time",
|
||||
getter = {
|
||||
val instant = thisAs<ObjInstant>().instant
|
||||
ObjReal(instant.epochSeconds + instant.nanosecondsOfSecond * 1e-9)
|
||||
}
|
||||
)
|
||||
addPropertyDoc(
|
||||
name = "isDistantFuture",
|
||||
doc = "Whether this instant represents the distant future.",
|
||||
type = type("lyng.Bool"),
|
||||
moduleName = "lyng.time",
|
||||
getter = { thisAs<ObjInstant>().instant.isDistantFuture.toObj() }
|
||||
)
|
||||
addPropertyDoc(
|
||||
name = "isDistantPast",
|
||||
doc = "Whether this instant represents the distant past.",
|
||||
type = type("lyng.Bool"),
|
||||
moduleName = "lyng.time",
|
||||
getter = { thisAs<ObjInstant>().instant.isDistantPast.toObj() }
|
||||
)
|
||||
addPropertyDoc(
|
||||
name = "epochWholeSeconds",
|
||||
doc = "Return the number of full seconds since the Unix epoch.",
|
||||
type = type("lyng.Int"),
|
||||
moduleName = "lyng.time",
|
||||
getter = { ObjInt(thisAs<ObjInstant>().instant.epochSeconds) }
|
||||
)
|
||||
addPropertyDoc(
|
||||
name = "nanosecondsOfSecond",
|
||||
doc = "The number of nanoseconds within the current second.",
|
||||
type = type("lyng.Int"),
|
||||
moduleName = "lyng.time",
|
||||
getter = { ObjInt(thisAs<ObjInstant>().instant.nanosecondsOfSecond.toLong()) }
|
||||
)
|
||||
addFnDoc(
|
||||
name = "truncateToMinute",
|
||||
doc = "Truncate this instant to the nearest minute.",
|
||||
returns = type("lyng.Instant"),
|
||||
moduleName = "lyng.time"
|
||||
) {
|
||||
val t = thisAs<ObjInstant>().instant
|
||||
val tz = TimeZone.UTC
|
||||
val dt = t.toLocalDateTime(tz)
|
||||
val truncated = LocalDateTime(dt.year, dt.month, dt.dayOfMonth, dt.hour, dt.minute, 0, 0)
|
||||
ObjInstant(truncated.toInstant(tz), LynonSettings.InstantTruncateMode.Second)
|
||||
}
|
||||
addFn("isDistantFuture") {
|
||||
thisAs<ObjInstant>().instant.isDistantFuture.toObj()
|
||||
}
|
||||
addFn("isDistantPast") {
|
||||
thisAs<ObjInstant>().instant.isDistantPast.toObj()
|
||||
}
|
||||
addFn("epochWholeSeconds") {
|
||||
ObjInt(thisAs<ObjInstant>().instant.epochSeconds)
|
||||
}
|
||||
addFn("nanosecondsOfSecond") {
|
||||
ObjInt(thisAs<ObjInstant>().instant.nanosecondsOfSecond.toLong())
|
||||
}
|
||||
addFn("truncateToSecond") {
|
||||
addFnDoc(
|
||||
name = "truncateToSecond",
|
||||
doc = "Truncate this instant to the nearest second.",
|
||||
returns = type("lyng.Instant"),
|
||||
moduleName = "lyng.time"
|
||||
) {
|
||||
val t = thisAs<ObjInstant>().instant
|
||||
ObjInstant(Instant.fromEpochSeconds(t.epochSeconds), LynonSettings.InstantTruncateMode.Second)
|
||||
}
|
||||
addFn("truncateToMillisecond") {
|
||||
addFnDoc(
|
||||
name = "truncateToMillisecond",
|
||||
doc = "Truncate this instant to the nearest millisecond.",
|
||||
returns = type("lyng.Instant"),
|
||||
moduleName = "lyng.time"
|
||||
) {
|
||||
val t = thisAs<ObjInstant>().instant
|
||||
ObjInstant(
|
||||
Instant.fromEpochSeconds(t.epochSeconds, t.nanosecondsOfSecond / 1_000_000 * 1_000_000),
|
||||
LynonSettings.InstantTruncateMode.Millisecond
|
||||
)
|
||||
}
|
||||
addFn("truncateToMicrosecond") {
|
||||
addFnDoc(
|
||||
name = "truncateToMicrosecond",
|
||||
doc = "Truncate this instant to the nearest microsecond.",
|
||||
returns = type("lyng.Instant"),
|
||||
moduleName = "lyng.time"
|
||||
) {
|
||||
val t = thisAs<ObjInstant>().instant
|
||||
ObjInstant(
|
||||
Instant.fromEpochSeconds(t.epochSeconds, t.nanosecondsOfSecond / 1_000 * 1_000),
|
||||
LynonSettings.InstantTruncateMode.Microsecond
|
||||
)
|
||||
}
|
||||
|
||||
addFnDoc(
|
||||
name = "toRFC3339",
|
||||
doc = "Return the RFC3339 string representation of this instant in UTC (e.g., '1970-01-01T00:00:00Z').",
|
||||
returns = type("lyng.String"),
|
||||
moduleName = "lyng.time"
|
||||
) {
|
||||
thisAs<ObjInstant>().instant.toString().toObj()
|
||||
}
|
||||
|
||||
addFnDoc(
|
||||
name = "toSortableString",
|
||||
doc = "Alias to toRFC3339.",
|
||||
returns = type("lyng.String"),
|
||||
moduleName = "lyng.time"
|
||||
) {
|
||||
thisAs<ObjInstant>().instant.toString().toObj()
|
||||
}
|
||||
|
||||
addFnDoc(
|
||||
name = "toDateTime",
|
||||
doc = "Convert this absolute instant to a localized DateTime object in the specified time zone. " +
|
||||
"Accepts a timezone ID string (e.g., 'UTC', '+02:00') or an integer offset in seconds. " +
|
||||
"If no argument is provided, the system's current default time zone is used.",
|
||||
params = listOf(net.sergeych.lyng.miniast.ParamDoc("tz", type = type("lyng.Any", true))),
|
||||
returns = type("lyng.DateTime"),
|
||||
moduleName = "lyng.time"
|
||||
) {
|
||||
val tz = when (val a = args.list.getOrNull(0)) {
|
||||
null -> TimeZone.currentSystemDefault()
|
||||
is ObjString -> TimeZone.of(a.value)
|
||||
is ObjInt -> UtcOffset(seconds = a.value.toInt()).asTimeZone()
|
||||
else -> raiseIllegalArgument("invalid timezone: $a")
|
||||
}
|
||||
ObjDateTime(thisAs<ObjInstant>().instant, tz)
|
||||
}
|
||||
|
||||
// class members
|
||||
|
||||
addClassConst("distantFuture", distantFuture)
|
||||
|
||||
@@ -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,6 +21,7 @@ import net.sergeych.lyng.Arguments
|
||||
import net.sergeych.lyng.Statement
|
||||
import net.sergeych.lyng.miniast.ParamDoc
|
||||
import net.sergeych.lyng.miniast.addFnDoc
|
||||
import net.sergeych.lyng.miniast.addPropertyDoc
|
||||
import net.sergeych.lyng.miniast.type
|
||||
|
||||
/**
|
||||
@@ -29,19 +30,20 @@ import net.sergeych.lyng.miniast.type
|
||||
val ObjIterable by lazy {
|
||||
ObjClass("Iterable").apply {
|
||||
|
||||
addFnDoc(
|
||||
addPropertyDoc(
|
||||
name = "toList",
|
||||
doc = "Collect elements of this iterable into a new list.",
|
||||
returns = type("lyng.List"),
|
||||
moduleName = "lyng.stdlib"
|
||||
) {
|
||||
val result = mutableListOf<Obj>()
|
||||
val iterator = thisObj.invokeInstanceMethod(this, "iterator")
|
||||
|
||||
while (iterator.invokeInstanceMethod(this, "hasNext").toBool())
|
||||
result += iterator.invokeInstanceMethod(this, "next")
|
||||
ObjList(result)
|
||||
}
|
||||
type = type("lyng.List"),
|
||||
moduleName = "lyng.stdlib",
|
||||
getter = {
|
||||
val result = mutableListOf<Obj>()
|
||||
val it = this.thisObj.invokeInstanceMethod(this, "iterator")
|
||||
while (it.invokeInstanceMethod(this, "hasNext").toBool()) {
|
||||
result.add(it.invokeInstanceMethod(this, "next"))
|
||||
}
|
||||
ObjList(result)
|
||||
}
|
||||
)
|
||||
|
||||
// it is not effective, but it is open:
|
||||
addFnDoc(
|
||||
@@ -55,7 +57,7 @@ val ObjIterable by lazy {
|
||||
val obj = args.firstAndOnly()
|
||||
val it = thisObj.invokeInstanceMethod(this, "iterator")
|
||||
while (it.invokeInstanceMethod(this, "hasNext").toBool()) {
|
||||
if (obj.compareTo(this, it.invokeInstanceMethod(this, "next")) == 0)
|
||||
if (obj.equals(this, it.invokeInstanceMethod(this, "next")))
|
||||
return@addFnDoc ObjTrue
|
||||
}
|
||||
ObjFalse
|
||||
@@ -73,46 +75,49 @@ val ObjIterable by lazy {
|
||||
var index = 0
|
||||
val it = thisObj.invokeInstanceMethod(this, "iterator")
|
||||
while (it.invokeInstanceMethod(this, "hasNext").toBool()) {
|
||||
if (obj.compareTo(this, it.invokeInstanceMethod(this, "next")) == 0)
|
||||
if (obj.equals(this, it.invokeInstanceMethod(this, "next")))
|
||||
return@addFnDoc ObjInt(index.toLong())
|
||||
index++
|
||||
}
|
||||
ObjInt(-1L)
|
||||
}
|
||||
|
||||
addFnDoc(
|
||||
addPropertyDoc(
|
||||
name = "toSet",
|
||||
doc = "Collect elements of this iterable into a new set.",
|
||||
returns = type("lyng.Set"),
|
||||
moduleName = "lyng.stdlib"
|
||||
) {
|
||||
if( thisObj.isInstanceOf(ObjSet.type) )
|
||||
thisObj
|
||||
else {
|
||||
val result = mutableSetOf<Obj>()
|
||||
val it = thisObj.invokeInstanceMethod(this, "iterator")
|
||||
while (it.invokeInstanceMethod(this, "hasNext").toBool()) {
|
||||
result += it.invokeInstanceMethod(this, "next")
|
||||
type = type("lyng.Set"),
|
||||
moduleName = "lyng.stdlib",
|
||||
getter = {
|
||||
if( this.thisObj.isInstanceOf(ObjSet.type) )
|
||||
this.thisObj
|
||||
else {
|
||||
val result = mutableSetOf<Obj>()
|
||||
val it = this.thisObj.invokeInstanceMethod(this, "iterator")
|
||||
while (it.invokeInstanceMethod(this, "hasNext").toBool()) {
|
||||
result.add(it.invokeInstanceMethod(this, "next"))
|
||||
}
|
||||
ObjSet(result)
|
||||
}
|
||||
ObjSet(result)
|
||||
}
|
||||
}
|
||||
)
|
||||
|
||||
addFnDoc(
|
||||
addPropertyDoc(
|
||||
name = "toMap",
|
||||
doc = "Collect pairs into a map using [0] as key and [1] as value for each element.",
|
||||
returns = type("lyng.Map"),
|
||||
moduleName = "lyng.stdlib"
|
||||
) {
|
||||
val result = mutableMapOf<Obj, Obj>()
|
||||
thisObj.toFlow(this).collect { pair ->
|
||||
when (pair) {
|
||||
is ObjMapEntry -> result[pair.key] = pair.value
|
||||
else -> result[pair.getAt(this, 0)] = pair.getAt(this, 1)
|
||||
type = type("lyng.Map"),
|
||||
moduleName = "lyng.stdlib",
|
||||
getter = {
|
||||
val result = mutableMapOf<Obj, Obj>()
|
||||
this.thisObj.enumerate(this) { pair ->
|
||||
when (pair) {
|
||||
is ObjMapEntry -> result[pair.key] = pair.value
|
||||
else -> result[pair.getAt(this, 0)] = pair.getAt(this, 1)
|
||||
}
|
||||
true
|
||||
}
|
||||
ObjMap(result)
|
||||
}
|
||||
ObjMap(result)
|
||||
}
|
||||
)
|
||||
|
||||
addFnDoc(
|
||||
name = "associateBy",
|
||||
@@ -156,7 +161,7 @@ val ObjIterable by lazy {
|
||||
val fn = requiredArg<Statement>(0)
|
||||
val result = mutableListOf<Obj>()
|
||||
thisObj.toFlow(this).collect {
|
||||
result += fn.call(this, it)
|
||||
result.add(fn.call(this, it))
|
||||
}
|
||||
ObjList(result)
|
||||
}
|
||||
@@ -173,7 +178,7 @@ val ObjIterable by lazy {
|
||||
val result = mutableListOf<Obj>()
|
||||
thisObj.toFlow(this).collect {
|
||||
val transformed = fn.call(this, it)
|
||||
if( transformed != ObjNull) result += transformed
|
||||
if( transformed != ObjNull) result.add(transformed)
|
||||
}
|
||||
ObjList(result)
|
||||
}
|
||||
@@ -189,25 +194,26 @@ val ObjIterable by lazy {
|
||||
val result = mutableListOf<Obj>()
|
||||
if (n > 0) {
|
||||
thisObj.enumerate(this) {
|
||||
result += it
|
||||
result.add(it)
|
||||
--n > 0
|
||||
}
|
||||
}
|
||||
ObjList(result)
|
||||
}
|
||||
|
||||
addFnDoc(
|
||||
addPropertyDoc(
|
||||
name = "isEmpty",
|
||||
doc = "Whether the iterable has no elements.",
|
||||
returns = type("lyng.Bool"),
|
||||
moduleName = "lyng.stdlib"
|
||||
) {
|
||||
ObjBool(
|
||||
thisObj.invokeInstanceMethod(this, "iterator")
|
||||
.invokeInstanceMethod(this, "hasNext").toBool()
|
||||
.not()
|
||||
)
|
||||
}
|
||||
type = type("lyng.Bool"),
|
||||
moduleName = "lyng.stdlib",
|
||||
getter = {
|
||||
ObjBool(
|
||||
this.thisObj.invokeInstanceMethod(this, "iterator")
|
||||
.invokeInstanceMethod(this, "hasNext").toBool()
|
||||
.not()
|
||||
)
|
||||
}
|
||||
)
|
||||
|
||||
addFnDoc(
|
||||
name = "sortedWith",
|
||||
|
||||
@@ -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,16 +22,30 @@ import kotlinx.serialization.json.JsonElement
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.Statement
|
||||
import net.sergeych.lyng.miniast.ParamDoc
|
||||
import net.sergeych.lyng.miniast.addConstDoc
|
||||
import net.sergeych.lyng.miniast.addFnDoc
|
||||
import net.sergeych.lyng.miniast.addPropertyDoc
|
||||
import net.sergeych.lyng.miniast.type
|
||||
import net.sergeych.lyng.statement
|
||||
import net.sergeych.lynon.LynonDecoder
|
||||
import net.sergeych.lynon.LynonEncoder
|
||||
import net.sergeych.lynon.LynonType
|
||||
|
||||
class ObjList(val list: MutableList<Obj> = mutableListOf()) : Obj() {
|
||||
|
||||
override suspend fun equals(scope: Scope, other: Obj): Boolean {
|
||||
if (this === other) return true
|
||||
if (other !is ObjList) {
|
||||
if (other.isInstanceOf(ObjIterable)) {
|
||||
return compareTo(scope, other) == 0
|
||||
}
|
||||
return false
|
||||
}
|
||||
if (list.size != other.list.size) return false
|
||||
for (i in 0..<list.size) {
|
||||
if (!list[i].equals(scope, other.list[i])) return false
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
override suspend fun getAt(scope: Scope, index: Obj): Obj {
|
||||
return when (index) {
|
||||
is ObjInt -> {
|
||||
@@ -77,21 +91,35 @@ class ObjList(val list: MutableList<Obj> = mutableListOf()) : Obj() {
|
||||
}
|
||||
|
||||
override suspend fun compareTo(scope: Scope, other: Obj): Int {
|
||||
if (other !is ObjList) return -2
|
||||
val mySize = list.size
|
||||
val otherSize = other.list.size
|
||||
val commonSize = minOf(mySize, otherSize)
|
||||
for (i in 0..<commonSize) {
|
||||
if (list[i].compareTo(scope, other.list[i]) != 0) {
|
||||
return list[i].compareTo(scope, other.list[i])
|
||||
if (other is ObjList) {
|
||||
val mySize = list.size
|
||||
val otherSize = other.list.size
|
||||
val commonSize = minOf(mySize, otherSize)
|
||||
for (i in 0..<commonSize) {
|
||||
val d = list[i].compareTo(scope, other.list[i])
|
||||
if (d != 0) {
|
||||
return d
|
||||
}
|
||||
}
|
||||
val res = mySize.compareTo(otherSize)
|
||||
return res
|
||||
}
|
||||
// equal so far, longer is greater:
|
||||
return when {
|
||||
mySize < otherSize -> -1
|
||||
mySize > otherSize -> 1
|
||||
else -> 0
|
||||
if (other.isInstanceOf(ObjIterable)) {
|
||||
val it1 = this.list.iterator()
|
||||
val it2 = other.invokeInstanceMethod(scope, "iterator")
|
||||
val hasNext2 = it2.getInstanceMethod(scope, "hasNext")
|
||||
val next2 = it2.getInstanceMethod(scope, "next")
|
||||
|
||||
while (it1.hasNext()) {
|
||||
if (!hasNext2.invoke(scope, it2).toBool()) return 1 // I'm longer
|
||||
val v1 = it1.next()
|
||||
val v2 = next2.invoke(scope, it2)
|
||||
val d = v1.compareTo(scope, v2)
|
||||
if (d != 0) return d
|
||||
}
|
||||
return if (hasNext2.invoke(scope, it2).toBool()) -1 else 0
|
||||
}
|
||||
return -2
|
||||
}
|
||||
|
||||
override suspend fun plus(scope: Scope, other: Obj): Obj =
|
||||
@@ -99,27 +127,28 @@ class ObjList(val list: MutableList<Obj> = mutableListOf()) : Obj() {
|
||||
other is ObjList ->
|
||||
ObjList((list + other.list).toMutableList())
|
||||
|
||||
other.isInstanceOf(ObjIterable) -> {
|
||||
other.isInstanceOf(ObjIterable) && other !is ObjString && other !is ObjBuffer -> {
|
||||
val l = other.callMethod<ObjList>(scope, "toList")
|
||||
ObjList((list + l.list).toMutableList())
|
||||
}
|
||||
|
||||
else ->
|
||||
scope.raiseError("'+': can't concatenate ${this.toString(scope)} with ${other.toString(scope)}")
|
||||
else -> {
|
||||
val newList = list.toMutableList()
|
||||
newList.add(other)
|
||||
ObjList(newList)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
override suspend fun plusAssign(scope: Scope, other: Obj): Obj {
|
||||
// optimization
|
||||
if (other is ObjList) {
|
||||
list += other.list
|
||||
return this
|
||||
list.addAll(other.list)
|
||||
} else if (other.isInstanceOf(ObjIterable) && other !is ObjString && other !is ObjBuffer) {
|
||||
val otherList = (other.invokeInstanceMethod(scope, "toList") as ObjList).list
|
||||
list.addAll(otherList)
|
||||
} else {
|
||||
list.add(other)
|
||||
}
|
||||
if (other.isInstanceOf(ObjIterable)) {
|
||||
val otherList = other.invokeInstanceMethod(scope, "toList") as ObjList
|
||||
list += otherList.list
|
||||
} else
|
||||
list += other
|
||||
return this
|
||||
}
|
||||
|
||||
@@ -222,26 +251,25 @@ class ObjList(val list: MutableList<Obj> = mutableListOf()) : Obj() {
|
||||
return ObjList(decoder.decodeAnyList(scope))
|
||||
}
|
||||
}.apply {
|
||||
addConstDoc(
|
||||
addPropertyDoc(
|
||||
name = "size",
|
||||
value = statement {
|
||||
(thisObj as ObjList).list.size.toObj()
|
||||
},
|
||||
doc = "Number of elements in this list.",
|
||||
type = type("lyng.Int"),
|
||||
moduleName = "lyng.stdlib"
|
||||
moduleName = "lyng.stdlib",
|
||||
getter = {
|
||||
val s = (this.thisObj as ObjList).list.size
|
||||
s.toObj()
|
||||
}
|
||||
)
|
||||
addConstDoc(
|
||||
addFnDoc(
|
||||
name = "add",
|
||||
value = statement {
|
||||
val l = thisAs<ObjList>().list
|
||||
for (a in args) l.add(a)
|
||||
ObjVoid
|
||||
},
|
||||
doc = "Append one or more elements to the end of this list.",
|
||||
type = type("lyng.Callable"),
|
||||
moduleName = "lyng.stdlib"
|
||||
)
|
||||
) {
|
||||
val l = thisAs<ObjList>().list
|
||||
for (a in args) l.add(a)
|
||||
ObjVoid
|
||||
}
|
||||
addFnDoc(
|
||||
name = "insertAt",
|
||||
doc = "Insert elements starting at the given index.",
|
||||
|
||||
@@ -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,10 +21,7 @@ import kotlinx.serialization.json.JsonElement
|
||||
import kotlinx.serialization.json.JsonObject
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.Statement
|
||||
import net.sergeych.lyng.miniast.ParamDoc
|
||||
import net.sergeych.lyng.miniast.TypeGenericDoc
|
||||
import net.sergeych.lyng.miniast.addFnDoc
|
||||
import net.sergeych.lyng.miniast.type
|
||||
import net.sergeych.lyng.miniast.*
|
||||
import net.sergeych.lynon.LynonDecoder
|
||||
import net.sergeych.lynon.LynonEncoder
|
||||
import net.sergeych.lynon.LynonType
|
||||
@@ -76,24 +73,27 @@ class ObjMapEntry(val key: Obj, val value: Obj) : Obj() {
|
||||
)
|
||||
}
|
||||
}.apply {
|
||||
addFnDoc(
|
||||
addPropertyDoc(
|
||||
name = "key",
|
||||
doc = "Key component of this map entry.",
|
||||
returns = type("lyng.Any"),
|
||||
moduleName = "lyng.stdlib"
|
||||
) { thisAs<ObjMapEntry>().key }
|
||||
addFnDoc(
|
||||
type = type("lyng.Any"),
|
||||
moduleName = "lyng.stdlib",
|
||||
getter = { thisAs<ObjMapEntry>().key }
|
||||
)
|
||||
addPropertyDoc(
|
||||
name = "value",
|
||||
doc = "Value component of this map entry.",
|
||||
returns = type("lyng.Any"),
|
||||
moduleName = "lyng.stdlib"
|
||||
) { thisAs<ObjMapEntry>().value }
|
||||
addFnDoc(
|
||||
type = type("lyng.Any"),
|
||||
moduleName = "lyng.stdlib",
|
||||
getter = { thisAs<ObjMapEntry>().value }
|
||||
)
|
||||
addPropertyDoc(
|
||||
name = "size",
|
||||
doc = "Number of components in this entry (always 2).",
|
||||
returns = type("lyng.Int"),
|
||||
moduleName = "lyng.stdlib"
|
||||
) { 2.toObj() }
|
||||
type = type("lyng.Int"),
|
||||
moduleName = "lyng.stdlib",
|
||||
getter = { 2.toObj() }
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -106,6 +106,18 @@ class ObjMapEntry(val key: Obj, val value: Obj) : Obj() {
|
||||
|
||||
class ObjMap(val map: MutableMap<Obj, Obj> = mutableMapOf()) : Obj() {
|
||||
|
||||
override suspend fun equals(scope: Scope, other: Obj): Boolean {
|
||||
if (this === other) return true
|
||||
if (other !is ObjMap) return false
|
||||
if (map.size != other.map.size) return false
|
||||
for ((k, v) in map) {
|
||||
val otherV = other.getAt(scope, k)
|
||||
if (otherV === ObjNull && !other.contains(scope, k)) return false
|
||||
if (!v.equals(scope, otherV)) return false
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
override val objClass get() = type
|
||||
|
||||
override suspend fun getAt(scope: Scope, index: Obj): Obj =
|
||||
@@ -120,7 +132,13 @@ class ObjMap(val map: MutableMap<Obj, Obj> = mutableMapOf()) : Obj() {
|
||||
}
|
||||
|
||||
override suspend fun compareTo(scope: Scope, other: Obj): Int {
|
||||
if( other is ObjMap && other.map == map) return 0
|
||||
if (other is ObjMap) {
|
||||
if (map == other.map) return 0
|
||||
if (map.size != other.map.size) return map.size.compareTo(other.map.size)
|
||||
// for same size, if they are not equal, we don't have a stable order
|
||||
// but let's try to be consistent
|
||||
return map.toString().compareTo(other.map.toString())
|
||||
}
|
||||
return -1
|
||||
}
|
||||
|
||||
@@ -247,14 +265,13 @@ class ObjMap(val map: MutableMap<Obj, Obj> = mutableMapOf()) : Obj() {
|
||||
lambda.execute(this)
|
||||
}
|
||||
}
|
||||
addFnDoc(
|
||||
addPropertyDoc(
|
||||
name = "size",
|
||||
doc = "Number of entries in the map.",
|
||||
returns = type("lyng.Int"),
|
||||
moduleName = "lyng.stdlib"
|
||||
) {
|
||||
thisAs<ObjMap>().map.size.toObj()
|
||||
}
|
||||
type = type("lyng.Int"),
|
||||
moduleName = "lyng.stdlib",
|
||||
getter = { (this.thisObj as ObjMap).map.size.toObj() }
|
||||
)
|
||||
addFnDoc(
|
||||
name = "remove",
|
||||
doc = "Remove the entry by key and return the previous value or null if absent.",
|
||||
@@ -273,22 +290,20 @@ class ObjMap(val map: MutableMap<Obj, Obj> = mutableMapOf()) : Obj() {
|
||||
thisAs<ObjMap>().map.clear()
|
||||
thisObj
|
||||
}
|
||||
addFnDoc(
|
||||
addPropertyDoc(
|
||||
name = "keys",
|
||||
doc = "List of keys in this map.",
|
||||
returns = TypeGenericDoc(type("lyng.List"), listOf(type("lyng.Any"))),
|
||||
moduleName = "lyng.stdlib"
|
||||
) {
|
||||
thisAs<ObjMap>().map.keys.toObj()
|
||||
}
|
||||
addFnDoc(
|
||||
type = TypeGenericDoc(type("lyng.List"), listOf(type("lyng.Any"))),
|
||||
moduleName = "lyng.stdlib",
|
||||
getter = { thisAs<ObjMap>().map.keys.toObj() }
|
||||
)
|
||||
addPropertyDoc(
|
||||
name = "values",
|
||||
doc = "List of values in this map.",
|
||||
returns = TypeGenericDoc(type("lyng.List"), listOf(type("lyng.Any"))),
|
||||
moduleName = "lyng.stdlib"
|
||||
) {
|
||||
ObjList(thisAs<ObjMap>().map.values.toMutableList())
|
||||
}
|
||||
type = TypeGenericDoc(type("lyng.List"), listOf(type("lyng.Any"))),
|
||||
moduleName = "lyng.stdlib",
|
||||
getter = { ObjList(thisAs<ObjMap>().map.values.toMutableList()) }
|
||||
)
|
||||
addFnDoc(
|
||||
name = "iterator",
|
||||
doc = "Iterator over map entries as MapEntry objects.",
|
||||
@@ -328,7 +343,14 @@ class ObjMap(val map: MutableMap<Obj, Obj> = mutableMapOf()) : Obj() {
|
||||
for (e in other.list) {
|
||||
val entry = when (e) {
|
||||
is ObjMapEntry -> e
|
||||
else -> scope.raiseIllegalArgument("map can only be merged with MapEntry elements; got $e")
|
||||
else -> {
|
||||
if (e.isInstanceOf(ObjArray)) {
|
||||
if (e.invokeInstanceMethod(scope, "size").toInt() != 2)
|
||||
scope.raiseIllegalArgument("Array element to merge into map must have 2 elements, got $e")
|
||||
ObjMapEntry(e.getAt(scope, 0), e.getAt(scope, 1))
|
||||
} else
|
||||
scope.raiseIllegalArgument("map can only be merged with MapEntry elements; got $e")
|
||||
}
|
||||
}
|
||||
map[entry.key] = entry.value
|
||||
}
|
||||
|
||||
@@ -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,6 +20,7 @@ package net.sergeych.lyng.obj
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.miniast.TypeGenericDoc
|
||||
import net.sergeych.lyng.miniast.addFnDoc
|
||||
import net.sergeych.lyng.miniast.addPropertyDoc
|
||||
import net.sergeych.lyng.miniast.type
|
||||
|
||||
class ObjRange(val start: Obj?, val end: Obj?, val isEndInclusive: Boolean) : Obj() {
|
||||
@@ -174,54 +175,48 @@ class ObjRange(val start: Obj?, val end: Obj?, val isEndInclusive: Boolean) : Ob
|
||||
|
||||
companion object {
|
||||
val type = ObjClass("Range", ObjIterable).apply {
|
||||
addFnDoc(
|
||||
addPropertyDoc(
|
||||
name = "start",
|
||||
doc = "Start bound of the range or null if open.",
|
||||
returns = type("lyng.Any", nullable = true),
|
||||
moduleName = "lyng.stdlib"
|
||||
) {
|
||||
thisAs<ObjRange>().start ?: ObjNull
|
||||
}
|
||||
addFnDoc(
|
||||
type = type("lyng.Any", nullable = true),
|
||||
moduleName = "lyng.stdlib",
|
||||
getter = { thisAs<ObjRange>().start ?: ObjNull }
|
||||
)
|
||||
addPropertyDoc(
|
||||
name = "end",
|
||||
doc = "End bound of the range or null if open.",
|
||||
returns = type("lyng.Any", nullable = true),
|
||||
moduleName = "lyng.stdlib"
|
||||
) {
|
||||
thisAs<ObjRange>().end ?: ObjNull
|
||||
}
|
||||
addFnDoc(
|
||||
type = type("lyng.Any", nullable = true),
|
||||
moduleName = "lyng.stdlib",
|
||||
getter = { thisAs<ObjRange>().end ?: ObjNull }
|
||||
)
|
||||
addPropertyDoc(
|
||||
name = "isOpen",
|
||||
doc = "Whether the range is open on either side (no start or no end).",
|
||||
returns = type("lyng.Bool"),
|
||||
moduleName = "lyng.stdlib"
|
||||
) {
|
||||
thisAs<ObjRange>().let { it.start == null || it.end == null }.toObj()
|
||||
}
|
||||
addFnDoc(
|
||||
type = type("lyng.Bool"),
|
||||
moduleName = "lyng.stdlib",
|
||||
getter = { thisAs<ObjRange>().let { it.start == null || it.end == null }.toObj() }
|
||||
)
|
||||
addPropertyDoc(
|
||||
name = "isIntRange",
|
||||
doc = "True if both bounds are Int values.",
|
||||
returns = type("lyng.Bool"),
|
||||
moduleName = "lyng.stdlib"
|
||||
) {
|
||||
thisAs<ObjRange>().isIntRange.toObj()
|
||||
}
|
||||
addFnDoc(
|
||||
type = type("lyng.Bool"),
|
||||
moduleName = "lyng.stdlib",
|
||||
getter = { thisAs<ObjRange>().isIntRange.toObj() }
|
||||
)
|
||||
addPropertyDoc(
|
||||
name = "isCharRange",
|
||||
doc = "True if both bounds are Char values.",
|
||||
returns = type("lyng.Bool"),
|
||||
moduleName = "lyng.stdlib"
|
||||
) {
|
||||
thisAs<ObjRange>().isCharRange.toObj()
|
||||
}
|
||||
addFnDoc(
|
||||
type = type("lyng.Bool"),
|
||||
moduleName = "lyng.stdlib",
|
||||
getter = { thisAs<ObjRange>().isCharRange.toObj() }
|
||||
)
|
||||
addPropertyDoc(
|
||||
name = "isEndInclusive",
|
||||
doc = "Whether the end bound is inclusive.",
|
||||
returns = type("lyng.Bool"),
|
||||
moduleName = "lyng.stdlib"
|
||||
) {
|
||||
thisAs<ObjRange>().isEndInclusive.toObj()
|
||||
}
|
||||
type = type("lyng.Bool"),
|
||||
moduleName = "lyng.stdlib",
|
||||
getter = { thisAs<ObjRange>().isEndInclusive.toObj() }
|
||||
)
|
||||
addFnDoc(
|
||||
name = "iterator",
|
||||
doc = "Iterator over elements in this range (optimized for Int ranges).",
|
||||
|
||||
@@ -36,6 +36,8 @@ data class ObjRecord(
|
||||
val isClosed: Boolean = false,
|
||||
val isOverride: Boolean = false,
|
||||
var delegate: Obj? = null,
|
||||
/** The receiver object to resolve this member against (for instance fields/methods). */
|
||||
var receiver: Obj? = null,
|
||||
) {
|
||||
val effectiveWriteVisibility: Visibility get() = writeVisibility ?: visibility
|
||||
enum class Type(val comparable: Boolean = false,val serializable: Boolean = false) {
|
||||
|
||||
File diff suppressed because it is too large.
Load diff
@@ -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,10 +20,7 @@ package net.sergeych.lyng.obj
|
||||
import net.sergeych.lyng.PerfFlags
|
||||
import net.sergeych.lyng.RegexCache
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.miniast.ParamDoc
|
||||
import net.sergeych.lyng.miniast.TypeGenericDoc
|
||||
import net.sergeych.lyng.miniast.addFnDoc
|
||||
import net.sergeych.lyng.miniast.type
|
||||
import net.sergeych.lyng.miniast.*
|
||||
|
||||
class ObjRegex(val regex: Regex) : Obj() {
|
||||
override val objClass get() = type
|
||||
@@ -123,30 +120,27 @@ class ObjRegexMatch(val match: MatchResult) : Obj() {
|
||||
scope.raiseError("RegexMatch can't be constructed directly")
|
||||
}
|
||||
}.apply {
|
||||
addFnDoc(
|
||||
addPropertyDoc(
|
||||
name = "groups",
|
||||
doc = "List of captured groups with index 0 as the whole match.",
|
||||
returns = TypeGenericDoc(type("lyng.List"), listOf(type("lyng.String"))),
|
||||
moduleName = "lyng.stdlib"
|
||||
) {
|
||||
thisAs<ObjRegexMatch>().objGroups
|
||||
}
|
||||
addFnDoc(
|
||||
type = TypeGenericDoc(type("lyng.List"), listOf(type("lyng.String"))),
|
||||
moduleName = "lyng.stdlib",
|
||||
getter = { thisAs<ObjRegexMatch>().objGroups }
|
||||
)
|
||||
addPropertyDoc(
|
||||
name = "value",
|
||||
doc = "The matched substring.",
|
||||
returns = type("lyng.String"),
|
||||
moduleName = "lyng.stdlib"
|
||||
) {
|
||||
thisAs<ObjRegexMatch>().objValue
|
||||
}
|
||||
addFnDoc(
|
||||
type = type("lyng.String"),
|
||||
moduleName = "lyng.stdlib",
|
||||
getter = { thisAs<ObjRegexMatch>().objValue }
|
||||
)
|
||||
addPropertyDoc(
|
||||
name = "range",
|
||||
doc = "Range of the match in the input (end-exclusive).",
|
||||
returns = type("lyng.Range"),
|
||||
moduleName = "lyng.stdlib"
|
||||
) {
|
||||
thisAs<ObjRegexMatch>().objRange
|
||||
}
|
||||
type = type("lyng.Range"),
|
||||
moduleName = "lyng.stdlib",
|
||||
getter = { thisAs<ObjRegexMatch>().objRange }
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Loaded 100 of 130 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user