Compare commits

...
2 Commits
18 changed files with 365 additions and 53 deletions

No files matched your search

+2
View File
@@ -98,6 +98,8 @@ All notable changes to this project will be documented in this file.
- Mutually exclusive: `--check` and `--in-place` together now produce an error and exit with code 1. - Mutually exclusive: `--check` and `--in-place` together now produce an error and exit with code 1.
- Multi-file stdout prints headers `--- <path> ---` per file. - Multi-file stdout prints headers `--- <path> ---` per file.
- `lyng --help` shows `fmt`; `lyng fmt --help` displays dedicated help. - `lyng --help` shows `fmt`; `lyng fmt --help` displays dedicated help.
- Fix: Property accessors (`get`, `set`, `private set`, `protected set`) are now correctly indented relative to the property declaration.
- Fix: Indentation now correctly carries over into blocks that start on extra‑indented lines (e.g., nested `if` statements or property accessor bodies).
- CLI: Preserved legacy script invocation fast-paths: - CLI: Preserved legacy script invocation fast-paths:
- `lyng script.lyng [args...]` executes the script directly. - `lyng script.lyng [args...]` executes the script directly.
+110
View File
@@ -0,0 +1,110 @@
# What's New in Lyng
This document highlights the latest additions and improvements to the Lyng language and its ecosystem.
## Language Features
### Class Properties with Accessors
Classes now support properties with custom `get()` and `set()` accessors. Properties in Lyng do **not** have automatic backing fields; they are pure accessors.
```lyng
class Person(private var _age: Int) {
// Read-only property
val ageCategory get() = if (_age < 18) "Minor" else "Adult"
// Read-write property
var age: Int
get() = _age
set(v) {
if (v >= 0) _age = v
}
}
```
### 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.
```lyng
class Counter {
var count = 0
private set // Field with private setter
fun increment() { count++ }
}
class AdvancedCounter : Counter {
var totalOperations = 0
protected set // Settable here and in further subclasses
}
let c = Counter()
c.increment() // OK
// c.count = 10 // Error: setter is private
```
### Late-initialized `val` Fields
`val` fields in classes can be declared without an immediate initializer, provided they are assigned exactly once. If accessed before initialization, they hold the special `Unset` singleton.
```lyng
class Service {
val logger
fun check() {
if (logger == Unset) println("Not initialized yet")
}
init {
logger = Logger("Service")
}
}
```
### Named Arguments and Named Splats
Function calls now support named arguments using the `name: value` syntax. If the variable name matches the parameter name, you can use the `name:` shorthand.
```lyng
fun greet(name, greeting = "Hello") {
println("$greeting, $name!")
}
val name = "Alice"
greet(name:) // Shorthand for greet(name: name)
greet(greeting: "Hi", name: "Bob")
let params = { name: "Charlie", greeting: "Hey")
greet(...params) // Named splat expansion
```
### Multiple Inheritance (MI)
Lyng now supports multiple inheritance using the C3 Method Resolution Order (MRO). Use `this@Type` or casts for disambiguation.
```lyng
class A { fun foo() = "A" }
class B { fun foo() = "B" }
class Derived : A, B {
fun test() {
println(foo()) // Resolves to A.foo (leftmost)
println(this@B.foo()) // Qualified dispatch to B.foo
}
}
let d = Derived()
println((d as B).foo()) // Disambiguation via cast
```
## Tooling and Infrastructure
### CLI: Formatting Command
A new `fmt` subcommand has been added to the Lyng CLI.
```bash
lyng fmt MyFile.lyng # Print formatted code to stdout
lyng fmt --in-place MyFile.lyng # Format file in-place
lyng fmt --check MyFile.lyng # Check if file needs formatting
```
### IDEA Plugin: Autocompletion
Experimental lightweight autocompletion is now available in the IntelliJ plugin. It features type-aware member suggestions and inheritance-aware completion.
You can enable it in **Settings | Lyng Formatter | Enable Lyng autocompletion**.
@@ -21,7 +21,6 @@
*/ */
package net.sergeych.lyng.idea.completion package net.sergeych.lyng.idea.completion
import LyngAstManager
import com.intellij.codeInsight.completion.* import com.intellij.codeInsight.completion.*
import com.intellij.codeInsight.lookup.LookupElementBuilder import com.intellij.codeInsight.lookup.LookupElementBuilder
import com.intellij.icons.AllIcons import com.intellij.icons.AllIcons
@@ -36,6 +35,7 @@ import net.sergeych.lyng.idea.LyngLanguage
import net.sergeych.lyng.idea.highlight.LyngTokenTypes import net.sergeych.lyng.idea.highlight.LyngTokenTypes
import net.sergeych.lyng.idea.settings.LyngFormatterSettings import net.sergeych.lyng.idea.settings.LyngFormatterSettings
import net.sergeych.lyng.idea.util.DocsBootstrap import net.sergeych.lyng.idea.util.DocsBootstrap
import net.sergeych.lyng.idea.util.LyngAstManager
import net.sergeych.lyng.idea.util.TextCtx import net.sergeych.lyng.idea.util.TextCtx
import net.sergeych.lyng.miniast.* import net.sergeych.lyng.miniast.*
@@ -85,7 +85,13 @@ class LyngEnterHandler : EnterHandlerDelegate {
if (code == "}" || code == "*/") { if (code == "}" || code == "*/") {
// Adjust indent for the previous line if it's a block or comment closer // Adjust indent for the previous line if it's a block or comment closer
val prevStart = doc.getLineStartOffset(prevLine) val prevStart = doc.getLineStartOffset(prevLine)
CodeStyleManager.getInstance(project).adjustLineIndent(file, prevStart) if (file.context == null) {
try {
CodeStyleManager.getInstance(project).adjustLineIndent(file, prevStart)
} catch (e: Exception) {
log.warn("Failed to adjust line indent for previous line: ${e.message}")
}
}
// Fallback for previous line: manual application // Fallback for previous line: manual application
val desiredPrev = computeDesiredIndent(project, doc, prevLine) val desiredPrev = computeDesiredIndent(project, doc, prevLine)
@@ -102,8 +108,13 @@ class LyngEnterHandler : EnterHandlerDelegate {
} }
// Adjust indent for the current (new) line // Adjust indent for the current (new) line
val currentStart = doc.getLineStartOffsetSafe(currentLine) val currentStart = doc.getLineStartOffsetSafe(currentLine)
val csm = CodeStyleManager.getInstance(project) if (file.context == null) {
csm.adjustLineIndent(file, currentStart) try {
CodeStyleManager.getInstance(project).adjustLineIndent(file, currentStart)
} catch (e: Exception) {
log.warn("Failed to adjust line indent for current line: ${e.message}")
}
}
// Fallback: if the platform didn't physically insert indentation, compute it from our formatter and apply // Fallback: if the platform didn't physically insert indentation, compute it from our formatter and apply
val lineStart = doc.getLineStartOffset(currentLine) val lineStart = doc.getLineStartOffset(currentLine)
@@ -58,7 +58,13 @@ class LyngTypedHandler : TypedHandlerDelegate() {
} }
// After block reindent, adjust line indent to what platform thinks (no-op in many cases) // After block reindent, adjust line indent to what platform thinks (no-op in many cases)
val lineStart = doc.getLineStartOffset(line) val lineStart = doc.getLineStartOffset(line)
CodeStyleManager.getInstance(project).adjustLineIndent(file, lineStart) if (file.context == null) {
try {
CodeStyleManager.getInstance(project).adjustLineIndent(file, lineStart)
} catch (e: Exception) {
log.warn("Failed to adjust line indent for current line: ${e.message}")
}
}
} }
} else if (c == '/') { } else if (c == '/') {
val doc = editor.document val doc = editor.document
@@ -67,7 +73,13 @@ class LyngTypedHandler : TypedHandlerDelegate() {
PsiDocumentManager.getInstance(project).commitDocument(doc) PsiDocumentManager.getInstance(project).commitDocument(doc)
val line = doc.getLineNumber(offset - 1) val line = doc.getLineNumber(offset - 1)
val lineStart = doc.getLineStartOffset(line) val lineStart = doc.getLineStartOffset(line)
CodeStyleManager.getInstance(project).adjustLineIndent(file, lineStart) if (file.context == null) {
try {
CodeStyleManager.getInstance(project).adjustLineIndent(file, lineStart)
} catch (e: Exception) {
log.warn("Failed to adjust line indent for comment: ${e.message}")
}
}
// Manual application fallback // Manual application fallback
val desired = computeDesiredIndent(project, doc, line) val desired = computeDesiredIndent(project, doc, line)
@@ -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"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@@ -80,7 +80,14 @@ class LyngPreFormatProcessor : PreFormatProcessor {
val lineStart = doc.getLineStartOffset(line) val lineStart = doc.getLineStartOffset(line)
// adjustLineIndent delegates to our LineIndentProvider which computes // adjustLineIndent delegates to our LineIndentProvider which computes
// indentation from scratch; this is safe and idempotent // indentation from scratch; this is safe and idempotent
CodeStyleManager.getInstance(project).adjustLineIndent(file, lineStart) if (file.context == null) {
try {
CodeStyleManager.getInstance(project).adjustLineIndent(file, lineStart)
} catch (e: Exception) {
// Log as debug because this can be called many times during reformat
// and we don't want to spam warnings if it's a known platform issue with injections
}
}
// After indentation, update block/paren/bracket balances using the current line text // After indentation, update block/paren/bracket balances using the current line text
val lineEnd = doc.getLineEndOffset(line) val lineEnd = doc.getLineEndOffset(line)
@@ -17,7 +17,6 @@
package net.sergeych.lyng.idea.navigation package net.sergeych.lyng.idea.navigation
import LyngAstManager
import com.intellij.lang.cacheBuilder.DefaultWordsScanner import com.intellij.lang.cacheBuilder.DefaultWordsScanner
import com.intellij.lang.cacheBuilder.WordsScanner import com.intellij.lang.cacheBuilder.WordsScanner
import com.intellij.lang.findUsages.FindUsagesProvider import com.intellij.lang.findUsages.FindUsagesProvider
@@ -26,6 +25,7 @@ import com.intellij.psi.PsiElement
import com.intellij.psi.tree.TokenSet import com.intellij.psi.tree.TokenSet
import net.sergeych.lyng.idea.highlight.LyngLexer import net.sergeych.lyng.idea.highlight.LyngLexer
import net.sergeych.lyng.idea.highlight.LyngTokenTypes import net.sergeych.lyng.idea.highlight.LyngTokenTypes
import net.sergeych.lyng.idea.util.LyngAstManager
import net.sergeych.lyng.miniast.DocLookupUtils import net.sergeych.lyng.miniast.DocLookupUtils
class LyngFindUsagesProvider : FindUsagesProvider { class LyngFindUsagesProvider : FindUsagesProvider {
@@ -17,10 +17,10 @@
package net.sergeych.lyng.idea.navigation package net.sergeych.lyng.idea.navigation
import LyngAstManager
import com.intellij.icons.AllIcons import com.intellij.icons.AllIcons
import com.intellij.ide.IconProvider import com.intellij.ide.IconProvider
import com.intellij.psi.PsiElement import com.intellij.psi.PsiElement
import net.sergeych.lyng.idea.util.LyngAstManager
import net.sergeych.lyng.miniast.DocLookupUtils import net.sergeych.lyng.miniast.DocLookupUtils
import javax.swing.Icon import javax.swing.Icon
@@ -17,13 +17,13 @@
package net.sergeych.lyng.idea.navigation package net.sergeych.lyng.idea.navigation
import LyngAstManager
import com.intellij.openapi.project.Project import com.intellij.openapi.project.Project
import com.intellij.openapi.util.TextRange import com.intellij.openapi.util.TextRange
import com.intellij.psi.* import com.intellij.psi.*
import com.intellij.psi.search.FilenameIndex import com.intellij.psi.search.FilenameIndex
import com.intellij.psi.search.GlobalSearchScope import com.intellij.psi.search.GlobalSearchScope
import net.sergeych.lyng.highlight.offsetOf import net.sergeych.lyng.highlight.offsetOf
import net.sergeych.lyng.idea.util.LyngAstManager
import net.sergeych.lyng.idea.util.TextCtx import net.sergeych.lyng.idea.util.TextCtx
import net.sergeych.lyng.miniast.* import net.sergeych.lyng.miniast.*
@@ -17,12 +17,12 @@
package net.sergeych.lyng.idea.navigation package net.sergeych.lyng.idea.navigation
import LyngAstManager
import com.intellij.patterns.PlatformPatterns import com.intellij.patterns.PlatformPatterns
import com.intellij.psi.* import com.intellij.psi.*
import com.intellij.util.ProcessingContext import com.intellij.util.ProcessingContext
import net.sergeych.lyng.idea.LyngLanguage import net.sergeych.lyng.idea.LyngLanguage
import net.sergeych.lyng.idea.highlight.LyngTokenTypes import net.sergeych.lyng.idea.highlight.LyngTokenTypes
import net.sergeych.lyng.idea.util.LyngAstManager
import net.sergeych.lyng.miniast.DocLookupUtils import net.sergeych.lyng.miniast.DocLookupUtils
class LyngPsiReferenceContributor : PsiReferenceContributor() { class LyngPsiReferenceContributor : PsiReferenceContributor() {
@@ -15,23 +15,6 @@
* *
*/ */
a/*
* 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.util package net.sergeych.lyng.idea.util
import com.intellij.openapi.util.Key import com.intellij.openapi.util.Key
+2 -2
View File
@@ -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"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.gradle.ExperimentalWasmDsl
import org.jetbrains.kotlin.gradle.dsl.JvmTarget import org.jetbrains.kotlin.gradle.dsl.JvmTarget
group = "net.sergeych" group = "net.sergeych"
version = "1.1.0-SNAPSHOT" version = "1.1.0-rc"
// Removed legacy buildscript classpath declarations; plugins are applied via the plugins DSL below // Removed legacy buildscript classpath declarations; plugins are applied via the plugins DSL below
@@ -113,6 +113,15 @@ object Binder {
symbols += fieldSym symbols += fieldSym
classes.last().fields += fieldSym.id classes.last().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)
symbols += fieldSym
classes.last().fields += fieldSym.id
}
} }
// Second pass: functions and top-level/class vals/vars // Second pass: functions and top-level/class vals/vars
@@ -24,6 +24,24 @@ package net.sergeych.lyng.format
*/ */
object LyngFormatter { object LyngFormatter {
private fun startsWithWord(s: String, w: String): Boolean =
s.startsWith(w) && s.getOrNull(w.length)?.let { !it.isLetterOrDigit() && it != '_' } != false
private fun isPropertyAccessor(s: String): Boolean {
val t = s.trim()
if (t.isEmpty()) return false
if (startsWithWord(t, "get") || startsWithWord(t, "set")) return true
if (startsWithWord(t, "private")) {
val rest = t.substring("private".length).trimStart()
if (startsWithWord(rest, "set")) return true
}
if (startsWithWord(t, "protected")) {
val rest = t.substring("protected".length).trimStart()
if (startsWithWord(rest, "set")) return true
}
return false
}
/** Returns the input with indentation recomputed from scratch, line by line. */ /** Returns the input with indentation recomputed from scratch, line by line. */
fun reindent(text: String, config: LyngFormatConfig = LyngFormatConfig()): String { fun reindent(text: String, config: LyngFormatConfig = LyngFormatConfig()): String {
// Normalize tabs to spaces globally before any transformation; results must contain no tabs // Normalize tabs to spaces globally before any transformation; results must contain no tabs
@@ -35,6 +53,7 @@ object LyngFormatter {
var bracketBalance = 0 var bracketBalance = 0
var prevBracketContinuation = false var prevBracketContinuation = false
var inBlockComment = false var inBlockComment = false
val extraIndents = mutableListOf<Int>()
// We don't keep per-"[" base alignment; continuation rules define alignment. // We don't keep per-"[" base alignment; continuation rules define alignment.
fun updateBalances(ch: Char) { fun updateBalances(ch: Char) {
@@ -52,7 +71,7 @@ object LyngFormatter {
// Always produce spaces; tabs are not allowed in resulting code // Always produce spaces; tabs are not allowed in resulting code
" ".repeat(level * config.indentSize + continuation) " ".repeat(level * config.indentSize + continuation)
var awaitingSingleIndent = false var awaitingExtraIndent = 0
fun isControlHeaderNoBrace(s: String): Boolean { fun isControlHeaderNoBrace(s: String): Boolean {
val t = s.trim() val t = s.trim()
if (t.isEmpty()) return false if (t.isEmpty()) return false
@@ -60,7 +79,13 @@ object LyngFormatter {
val isIf = Regex("^if\\s*\\(.*\\)\\s*$").matches(t) val isIf = Regex("^if\\s*\\(.*\\)\\s*$").matches(t)
val isElseIf = Regex("^else\\s+if\\s*\\(.*\\)\\s*$").matches(t) val isElseIf = Regex("^else\\s+if\\s*\\(.*\\)\\s*$").matches(t)
val isElse = t == "else" val isElse = t == "else"
return isIf || isElseIf || isElse if (isIf || isElseIf || isElse) return true
// property accessors ending with ) or =
if (isPropertyAccessor(t)) {
return if (t.contains('=')) t.endsWith('=') else t.endsWith(')')
}
return false
} }
for ((i, rawLine) in lines.withIndex()) { for ((i, rawLine) in lines.withIndex()) {
@@ -70,7 +95,12 @@ object LyngFormatter {
val trimmedLine = rawLine.trim() val trimmedLine = rawLine.trim()
// Compute effective indent level for this line // Compute effective indent level for this line
var effectiveLevel = blockLevel val currentExtraIndent = extraIndents.sum()
var effectiveLevel = blockLevel + currentExtraIndent
val isAccessor = !inBlockComment && isPropertyAccessor(trimmedStart)
if (isAccessor) effectiveLevel += 1
if (inBlockComment) { if (inBlockComment) {
if (!trimmedLine.startsWith("*/")) { if (!trimmedLine.startsWith("*/")) {
effectiveLevel += 1 effectiveLevel += 1
@@ -83,9 +113,9 @@ object LyngFormatter {
// Single-line control header (if/else/else if) without braces: indent the next // Single-line control header (if/else/else if) without braces: indent the next
// non-empty, non-'}', non-'else' line by one extra level // non-empty, non-'}', non-'else' line by one extra level
val applyAwaiting = awaitingSingleIndent && trimmedStart.isNotEmpty() && val applyAwaiting = awaitingExtraIndent > 0 && trimmedStart.isNotEmpty() &&
!trimmedStart.startsWith("else") && !trimmedStart.startsWith("}") !trimmedStart.startsWith("else") && !trimmedStart.startsWith("}")
if (applyAwaiting) effectiveLevel += 1 if (applyAwaiting) effectiveLevel += awaitingExtraIndent
val firstChar = trimmedStart.firstOrNull() val firstChar = trimmedStart.firstOrNull()
// While inside parentheses, continuation applies scaled by nesting level // While inside parentheses, continuation applies scaled by nesting level
@@ -129,23 +159,43 @@ object LyngFormatter {
// New line (keep EOF semantics similar to input) // New line (keep EOF semantics similar to input)
if (i < lines.lastIndex) sb.append('\n') if (i < lines.lastIndex) sb.append('\n')
val oldBlockLevel = blockLevel
// Update balances using this line's code content // Update balances using this line's code content
for (part in parts) { for (part in parts) {
if (part.type == PartType.Code) { if (part.type == PartType.Code) {
for (ch in part.text) updateBalances(ch) for (ch in part.text) updateBalances(ch)
} }
} }
val newBlockLevel = blockLevel
if (newBlockLevel > oldBlockLevel) {
val addedThisLine = (if (applyAwaiting) awaitingExtraIndent else 0) + (if (isAccessor) 1 else 0)
repeat(newBlockLevel - oldBlockLevel) {
extraIndents.add(addedThisLine)
}
} else if (newBlockLevel < oldBlockLevel) {
repeat(oldBlockLevel - newBlockLevel) {
if (extraIndents.isNotEmpty()) extraIndents.removeAt(extraIndents.size - 1)
}
}
inBlockComment = nextInBlockComment inBlockComment = nextInBlockComment
// Update awaitingSingleIndent based on current line // Update awaitingExtraIndent based on current line
if (applyAwaiting && trimmedStart.isNotEmpty()) { if (applyAwaiting && trimmedStart.isNotEmpty()) {
// we have just consumed the body line // we have just applied it.
awaitingSingleIndent = false val endsWithBrace = code.trimEnd().endsWith("{")
if (!endsWithBrace && isControlHeaderNoBrace(code)) {
// It's another header, increment
awaitingExtraIndent += if (isAccessor) 2 else 1
} else {
// It's the body, reset
awaitingExtraIndent = 0
}
} else { } else {
// start awaiting if current line is a control header without '{' // start awaiting if current line is a control header without '{'
val endsWithBrace = code.trimEnd().endsWith("{") val endsWithBrace = code.trimEnd().endsWith("{")
if (!endsWithBrace && isControlHeaderNoBrace(code)) { if (!endsWithBrace && isControlHeaderNoBrace(code)) {
awaitingSingleIndent = true awaitingExtraIndent = if (isAccessor) 2 else 1
} }
} }
@@ -196,9 +246,6 @@ object LyngFormatter {
return applyControlledWrapping(spacedText, config) return applyControlledWrapping(spacedText, config)
} }
private fun startsWithWord(s: String, w: String): Boolean =
s.startsWith(w) && s.getOrNull(w.length)?.let { !it.isLetterOrDigit() && it != '_' } != false
/** /**
* Reindents a slice of [text] specified by [range] and returns a new string with that slice replaced. * Reindents a slice of [text] specified by [range] and returns a new string with that slice replaced.
* By default, preserves the base indent of the first line in the slice (so the block stays at * By default, preserves the base indent of the first line in the slice (so the block stays at
@@ -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"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@@ -42,10 +42,10 @@ private val fallbackKeywordIds = setOf(
"and", "or", "not", "and", "or", "not",
// declarations & modifiers // declarations & modifiers
"fun", "fn", "class", "enum", "val", "var", "import", "package", "fun", "fn", "class", "enum", "val", "var", "import", "package",
"private", "protected", "static", "open", "extern", "private", "protected", "static", "open", "extern", "init", "get", "set", "by",
// control flow and misc // control flow and misc
"if", "else", "when", "while", "do", "for", "try", "catch", "finally", "if", "else", "when", "while", "do", "for", "try", "catch", "finally",
"throw", "return", "break", "continue", "this", "null", "true", "false" "throw", "return", "break", "continue", "this", "null", "true", "false", "unset"
) )
/** Maps lexer token type (and sometimes value) to a [HighlightKind]. */ /** Maps lexer token type (and sometimes value) to a [HighlightKind]. */
@@ -730,4 +730,124 @@ class LyngFormatterTest {
assertEquals(expected, formatted) assertEquals(expected, formatted)
} }
@Test
fun privateSet_indentation() {
val src = """
class A {
var x = 1
private set
}
""".trimIndent()
// What we expect: private set should be indented relative to the property
val expected = """
class A {
var x = 1
private set
}
""".trimIndent()
val cfg = LyngFormatConfig(indentSize = 4, continuationIndentSize = 4)
val out = LyngFormatter.reindent(src, cfg)
assertEquals(expected, out)
}
@Test
fun propertyAccessors_indentation() {
val src = """
class A {
var x
get() = 1
private set(v) {
_x = v
}
}
""".trimIndent()
val expected = """
class A {
var x
get() = 1
private set(v) {
_x = v
}
}
""".trimIndent()
val cfg = LyngFormatConfig(indentSize = 4, continuationIndentSize = 4)
val out = LyngFormatter.reindent(src, cfg)
assertEquals(expected, out)
}
@Test
fun nestedAwaitingIndentation() {
val src = """
if (cond)
if (other)
fun f() {
stmt
}
""".trimIndent()
val expected = """
if (cond)
if (other)
fun f() {
stmt
}
""".trimIndent()
val cfg = LyngFormatConfig(indentSize = 4, continuationIndentSize = 4)
val out = LyngFormatter.reindent(src, cfg)
assertEquals(expected, out)
}
@Test
fun propertyAccessor_followedByMethod() {
val src = """
var state: BarRequestState get() = getState()
set(value) = setState(value)
fun save() { cell.value = this }
""".trimIndent()
val expected = """
var state: BarRequestState get() = getState()
set(value) = setState(value)
fun save() { cell.value = this }
""".trimIndent()
val cfg = LyngFormatConfig(indentSize = 4, continuationIndentSize = 4)
val out = LyngFormatter.reindent(src, cfg)
assertEquals(expected, out)
}
@Test
fun propertyAccessor_dangling() {
val src1 = """
var x
get()
= 1
""".trimIndent()
val expected1 = """
var x
get()
= 1
""".trimIndent()
assertEquals(expected1, LyngFormatter.reindent(src1, LyngFormatConfig(indentSize = 4)))
val src2 = """
var x
get() =
1
""".trimIndent()
val expected2 = """
var x
get() =
1
""".trimIndent()
assertEquals(expected2, LyngFormatter.reindent(src2, LyngFormatConfig(indentSize = 4)))
}
} }
@@ -28,10 +28,7 @@ import net.sergeych.lyng.binding.SymbolKind
import net.sergeych.lyng.highlight.HighlightKind import net.sergeych.lyng.highlight.HighlightKind
import net.sergeych.lyng.highlight.SimpleLyngHighlighter import net.sergeych.lyng.highlight.SimpleLyngHighlighter
import net.sergeych.lyng.highlight.offsetOf import net.sergeych.lyng.highlight.offsetOf
import net.sergeych.lyng.miniast.MiniAstBuilder import net.sergeych.lyng.miniast.*
import net.sergeych.lyng.miniast.MiniClassDecl
import net.sergeych.lyng.miniast.MiniFunDecl
import net.sergeych.lyng.miniast.MiniTypeName
import org.w3c.dom.HTMLStyleElement import org.w3c.dom.HTMLStyleElement
fun ensureBootstrapCodeBlocks(html: String): String { fun ensureBootstrapCodeBlocks(html: String): String {
@@ -367,6 +364,7 @@ suspend fun applyLyngHighlightToTextAst(text: String): String {
is MiniFunDecl -> putName(d.nameStart, d.name, "hl-fn") is MiniFunDecl -> putName(d.nameStart, d.name, "hl-fn")
is MiniClassDecl -> putName(d.nameStart, d.name, "hl-class") is MiniClassDecl -> putName(d.nameStart, d.name, "hl-class")
is net.sergeych.lyng.miniast.MiniValDecl -> putName(d.nameStart, d.name, if (d.mutable) "hl-var" else "hl-val") is net.sergeych.lyng.miniast.MiniValDecl -> putName(d.nameStart, d.name, if (d.mutable) "hl-var" else "hl-val")
is MiniEnumDecl -> putName(d.nameStart, d.name, "hl-class")
} }
} }
// Imports: color each segment as directive/path // Imports: color each segment as directive/path
@@ -404,6 +402,7 @@ suspend fun applyLyngHighlightToTextAst(text: String): String {
} }
is net.sergeych.lyng.miniast.MiniValDecl -> addTypeSegments(d.type) is net.sergeych.lyng.miniast.MiniValDecl -> addTypeSegments(d.type)
is MiniClassDecl -> {} is MiniClassDecl -> {}
is MiniEnumDecl -> {}
} }
} }
@@ -534,7 +533,8 @@ private fun detectDeclarationAndParamOverrides(text: String): Map<Pair<Int, Int>
"package", "import", "fun", "fn", "class", "enum", "val", "var", "package", "import", "fun", "fn", "class", "enum", "val", "var",
"if", "else", "while", "do", "for", "when", "try", "catch", "finally", "if", "else", "while", "do", "for", "when", "try", "catch", "finally",
"throw", "return", "break", "continue", "in", "is", "as", "as?", "not", "throw", "return", "break", "continue", "in", "is", "as", "as?", "not",
"true", "false", "null", "private", "protected", "open", "extern", "static" "true", "false", "null", "private", "protected", "open", "extern", "static",
"init", "get", "set", "Unset", "by"
) )
fun skipWs(idx0: Int): Int { fun skipWs(idx0: Int): Int {
var idx = idx0 var idx = idx0
+13 -2
View File
@@ -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"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@@ -127,7 +127,7 @@ fun ReferencePage() {
Ul({ classes("mt-2") }) { Ul({ classes("mt-2") }) {
d.members.forEach { m -> d.members.forEach { m ->
when (m) { when (m) {
is MiniMemberFunDecl, -> { is MiniMemberFunDecl -> {
val params = m.params.joinToString(", ") { p -> val params = m.params.joinToString(", ") { p ->
val ts = typeOf(p.type) val ts = typeOf(p.type)
if (ts.isNotBlank()) "${p.name}${ts}" else p.name if (ts.isNotBlank()) "${p.name}${ts}" else p.name
@@ -150,6 +150,17 @@ fun ReferencePage() {
} }
} }
} }
is MiniEnumDecl -> {
Div { Text("enum ${d.name}") }
d.doc?.summary?.let { Small({ classes("text-muted") }) { Text(it) } }
if (d.entries.isNotEmpty()) {
Ul({ classes("mt-2") }) {
d.entries.forEach { entry ->
Li { Text(entry) }
}
}
}
}
} }
} }
} }