Compare commits

...
4 Commits
28 changed files with 370 additions and 1327 deletions

No files matched your search

+8 -2
View File
@@ -1252,7 +1252,7 @@ The same with `--`:
sum sum
>>> 5050 >>> 5050
There are self-assigning version for operators too: There is a self-assigning version for operators too:
var count = 100 var count = 100
var sum = 0 var sum = 0
@@ -1471,7 +1471,13 @@ Part match:
assert( "foo" == $~.value ) assert( "foo" == $~.value )
>>> void >>> 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 | | fun/prop | description / notes |
|----------------------|------------------------------------------------------------| |----------------------|------------------------------------------------------------|
@@ -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,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 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 Error(val start: Int, val end: Int, val message: String)
data class Result(val modStamp: Long, val spans: List<Span>, val error: Error? = null, 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())
override fun collectInformation(file: PsiFile): Input? { override fun collectInformation(file: PsiFile): Input? {
val doc: Document = file.viewProvider.document ?: return null val doc: Document = file.viewProvider.document ?: return null
@@ -318,32 +315,20 @@ class LyngExternalAnnotator : ExternalAnnotator<LyngExternalAnnotator.Input, Lyn
} }
} }
// Map Enum constants from token highlighter to IDEA enum constant color tokens.forEach { s ->
run { if (s.kind == HighlightKind.EnumConstant) {
tokens.forEach { s -> val start = s.range.start
if (s.kind == HighlightKind.EnumConstant) { val end = s.range.endExclusive
val start = s.range.start if (start in 0..end && end <= text.length && start < end) {
val end = s.range.endExclusive putRange(start, end, LyngHighlighterColors.ENUM_CONSTANT)
if (start in 0..end && end <= text.length && start < end) {
putRange(start, end, LyngHighlighterColors.ENUM_CONSTANT)
}
} }
} }
} }
// Build spell index payload: identifiers + comments/strings from simple highlighter. return Result(collectedInfo.modStamp, out, null)
// We use the highlighter as the source of truth for all "words" to check, including
// identifiers that might not be bound by the Binder.
val idRanges = tokens.filter { it.kind == HighlightKind.Identifier }.map { it.range.start until it.range.endExclusive }
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)
} }
override fun apply(file: PsiFile, annotationResult: Result?, holder: AnnotationHolder) { override fun apply(file: PsiFile, annotationResult: Result?, holder: AnnotationHolder) {
if (annotationResult == null) return if (annotationResult == null) return
// Skip if cache is up-to-date // Skip if cache is up-to-date
@@ -354,32 +339,6 @@ class LyngExternalAnnotator : ExternalAnnotator<LyngExternalAnnotator.Input, Lyn
val doc = file.viewProvider.document 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) { for (s in result.spans) {
holder.newSilentAnnotation(HighlightSeverity.INFORMATION) holder.newSilentAnnotation(HighlightSeverity.INFORMATION)
.range(TextRange(s.start, s.end)) .range(TextRange(s.start, s.end))
@@ -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,635 +0,0 @@
/*
* 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.
*
*/
/*
* 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}")
for (f in findings) {
val ab = holder.newAnnotation(HighlightSeverity.INFORMATION, f.message).range(f.range)
applyTypoStyleIfRequested(file, ab)
ab.create()
}
// SUPPLEMENT: Always run the fallback spellchecker to ensure spelling errors are not ignored.
// It will avoid duplicating findings already reported by Grazie.
val painted = fallbackWithLegacySpellcheckerIfAvailable(file, fragments, holder, findings)
if (painted > 0) {
log.info("LyngGrazieAnnotator.apply: supplemented with $painted typos from legacy engine")
}
}
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,
existingFindings: List<Finding>
): 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, existingFindings)
}
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, existingFindings)
}
var painted = 0
val docText = file.viewProvider.document?.text ?: return 0
val tokenRegex = Regex("[A-Za-z][A-Za-z0-9_']{2,}")
val settings = LyngFormatterSettings.getInstance(file.project)
val learned = settings.learnedWords
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, learned)) continue
// 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)
// Avoid duplicating findings from Grazie
if (existingFindings.any { it.range.intersects(abs) }) 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) {
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, existingFindings)
}
}
private fun naiveFallbackPaint(
file: PsiFile,
fragments: List<Pair<TextContent, TextRange>>,
holder: AnnotationHolder,
existingFindings: List<Finding>
): Int {
var painted = 0
val docText = file.viewProvider.document?.text
val tokenRegex = Regex("[A-Za-z][A-Za-z0-9_']{2,}")
val settings = LyngFormatterSettings.getInstance(file.project)
val learned = settings.learnedWords
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, learned)) continue
val localStart = m.range.first + token.indexOf(part)
val localEnd = localStart + part.length
val abs = TextRange(hostRange.startOffset + localStart, hostRange.startOffset + localEnd)
// Avoid duplicating findings from Grazie
if (existingFindings.any { it.range.intersects(abs) }) 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) {
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 fromSpellChecker = try {
val mgrCls = Class.forName("com.intellij.spellchecker.SpellCheckerManager")
val getInstance = mgrCls.methods.firstOrNull { it.name == "getInstance" && it.parameterCount == 1 }
val getSuggestions = mgrCls.methods.firstOrNull { it.name == "getSuggestions" && it.parameterCount == 1 && it.parameterTypes[0] == String::class.java }
val mgr = getInstance?.invoke(null, file.project)
if (mgr != null && getSuggestions != null) {
@Suppress("UNCHECKED_CAST")
getSuggestions.invoke(mgr, word) as? List<String>
} else null
} catch (_: Throwable) {
null
} ?: emptyList()
// Merge with priority: project (p=0), spellchecker (p=1)
val all = LinkedHashSet<String>()
// Add project words that are close enough
for (w in fromProject) {
if (w == lower) continue
if (kotlin.math.abs(w.length - lower.length) <= 2 && editDistance(lower, w) <= 2) {
all.add(w)
}
}
all.addAll(fromSpellChecker)
return all.take(16).toList()
}
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, learnedWords: Set<String> = emptySet()): Boolean {
val s = w.lowercase()
if (s in learnedWords) return true
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",
// Lyng technical/vocabulary words formerly in TechDictionary
"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"
)
}
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"); * 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.
@@ -19,86 +19,29 @@ package net.sergeych.lyng.idea.grazie
import com.intellij.grazie.text.TextContent import com.intellij.grazie.text.TextContent
import com.intellij.grazie.text.TextContent.TextDomain import com.intellij.grazie.text.TextContent.TextDomain
import com.intellij.grazie.text.TextExtractor import com.intellij.grazie.text.TextExtractor
import com.intellij.openapi.diagnostic.Logger
import com.intellij.psi.PsiElement import com.intellij.psi.PsiElement
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.psi.LyngElementTypes
import net.sergeych.lyng.idea.spell.LyngSpellIndex
/** /**
* Provides Grazie with extractable text for Lyng PSI elements. * Simplified TextExtractor for Lyng.
* We return text for identifiers, comments, and (optionally) string literals. * Designates areas for Natural Languages (Grazie) to check.
* printf-like specifiers are filtered by the Grammar strategy via stealth ranges.
*/ */
class LyngTextExtractor : TextExtractor() { 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? { override fun buildTextContent(element: PsiElement, allowedDomains: Set<TextDomain>): TextContent? {
val type = element.node?.elementType ?: return null 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) } 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
}
// Decide target domain by intersection with our MiniAst-driven index; prefer comments > strings > identifiers if (!allowedDomains.contains(domain)) return null
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 return TextContent.psiFragment(domain, element)
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
}
} }
} }
@@ -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
}
}
}
@@ -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"); * 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.
@@ -45,7 +45,68 @@ class LyngParserDefinition : ParserDefinition {
override fun createParser(project: Project?): PsiParser = PsiParser { root, builder -> override fun createParser(project: Project?): PsiParser = PsiParser { root, builder ->
val mark: PsiBuilder.Marker = builder.mark() 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) mark.done(root)
builder.treeBuilt 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"); * 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.
@@ -32,24 +32,6 @@ class LyngFormatterSettings(private val project: Project) : PersistentStateCompo
var reindentClosedBlockOnEnter: Boolean = true, var reindentClosedBlockOnEnter: Boolean = true,
var reindentPastedBlocks: Boolean = true, var reindentPastedBlocks: Boolean = true,
var normalizeBlockCommentIndent: Boolean = false, 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) // Experimental: enable Lyng autocompletion (can be disabled if needed)
var enableLyngCompletionExperimental: Boolean = true, var enableLyngCompletionExperimental: Boolean = true,
) )
@@ -82,42 +64,6 @@ class LyngFormatterSettings(private val project: Project) : PersistentStateCompo
get() = myState.normalizeBlockCommentIndent get() = myState.normalizeBlockCommentIndent
set(value) { myState.normalizeBlockCommentIndent = value } 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 var enableLyngCompletionExperimental: Boolean
get() = myState.enableLyngCompletionExperimental get() = myState.enableLyngCompletionExperimental
set(value) { myState.enableLyngCompletionExperimental = value } set(value) { myState.enableLyngCompletionExperimental = 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"); * 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.
@@ -30,14 +30,6 @@ class LyngFormatterSettingsConfigurable(private val project: Project) : Configur
private var reindentClosedBlockCb: JCheckBox? = null private var reindentClosedBlockCb: JCheckBox? = null
private var reindentPasteCb: JCheckBox? = null private var reindentPasteCb: JCheckBox? = null
private var normalizeBlockCommentIndentCb: 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 private var enableCompletionCb: JCheckBox? = null
override fun getDisplayName(): String = "Lyng Formatter" 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 '}'") reindentClosedBlockCb = JCheckBox("Reindent enclosed block on Enter after '}'")
reindentPasteCb = JCheckBox("Reindent pasted blocks (align pasted code to current indent)") reindentPasteCb = JCheckBox("Reindent pasted blocks (align pasted code to current indent)")
normalizeBlockCommentIndentCb = JCheckBox("Normalize block comment indentation [experimental]") 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)") enableCompletionCb = JCheckBox("Enable Lyng autocompletion (experimental)")
// Tooltips / short help // 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." 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." 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)." 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)." enableCompletionCb?.toolTipText = "Turn on/off the lightweight Lyng code completion (BASIC)."
p.add(spacingCb) p.add(spacingCb)
p.add(wrappingCb) p.add(wrappingCb)
p.add(reindentClosedBlockCb) p.add(reindentClosedBlockCb)
p.add(reindentPasteCb) p.add(reindentPasteCb)
p.add(normalizeBlockCommentIndentCb) 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) p.add(enableCompletionCb)
panel = p panel = p
reset() reset()
@@ -100,14 +69,6 @@ class LyngFormatterSettingsConfigurable(private val project: Project) : Configur
reindentClosedBlockCb?.isSelected != s.reindentClosedBlockOnEnter || reindentClosedBlockCb?.isSelected != s.reindentClosedBlockOnEnter ||
reindentPasteCb?.isSelected != s.reindentPastedBlocks || reindentPasteCb?.isSelected != s.reindentPastedBlocks ||
normalizeBlockCommentIndentCb?.isSelected != s.normalizeBlockCommentIndent || 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 enableCompletionCb?.isSelected != s.enableLyngCompletionExperimental
} }
@@ -118,14 +79,6 @@ class LyngFormatterSettingsConfigurable(private val project: Project) : Configur
s.reindentClosedBlockOnEnter = reindentClosedBlockCb?.isSelected == true s.reindentClosedBlockOnEnter = reindentClosedBlockCb?.isSelected == true
s.reindentPastedBlocks = reindentPasteCb?.isSelected == true s.reindentPastedBlocks = reindentPasteCb?.isSelected == true
s.normalizeBlockCommentIndent = normalizeBlockCommentIndentCb?.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 s.enableLyngCompletionExperimental = enableCompletionCb?.isSelected == true
} }
@@ -136,14 +89,6 @@ class LyngFormatterSettingsConfigurable(private val project: Project) : Configur
reindentClosedBlockCb?.isSelected = s.reindentClosedBlockOnEnter reindentClosedBlockCb?.isSelected = s.reindentClosedBlockOnEnter
reindentPasteCb?.isSelected = s.reindentPastedBlocks reindentPasteCb?.isSelected = s.reindentPastedBlocks
normalizeBlockCommentIndentCb?.isSelected = s.normalizeBlockCommentIndent 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 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}")
}
}
@@ -16,106 +16,26 @@
*/ */
package net.sergeych.lyng.idea.spell package net.sergeych.lyng.idea.spell
// Avoid Tokenizers helper to keep compatibility; implement our own tokenizers
import com.intellij.openapi.util.TextRange
import com.intellij.psi.PsiElement import com.intellij.psi.PsiElement
import com.intellij.spellchecker.inspections.PlainTextSplitter
import com.intellij.spellchecker.tokenizer.SpellcheckingStrategy import com.intellij.spellchecker.tokenizer.SpellcheckingStrategy
import com.intellij.spellchecker.tokenizer.TokenConsumer
import com.intellij.spellchecker.tokenizer.Tokenizer 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: * Standard IntelliJ spellchecking strategy for Lyng.
* - Identifiers: checked as identifiers * Uses the simplified PSI structure to identify declarations.
* - 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.
*/ */
class LyngSpellcheckingStrategy : SpellcheckingStrategy() { class LyngSpellcheckingStrategy : SpellcheckingStrategy() {
override fun getTokenizer(element: PsiElement?): Tokenizer<*> {
override fun getTokenizer(element: PsiElement): Tokenizer<*> { val type = element?.node?.elementType
if (element is com.intellij.psi.PsiFile) return EMPTY_TOKENIZER return when (type) {
LyngTokenTypes.LINE_COMMENT, LyngTokenTypes.BLOCK_COMMENT -> TEXT_TOKENIZER
val settings = LyngFormatterSettings.getInstance(element.project) LyngTokenTypes.STRING -> TEXT_TOKENIZER
val et = element.node?.elementType LyngElementTypes.NAME_IDENTIFIER,
LyngElementTypes.PARAMETER_NAME,
if (et == net.sergeych.lyng.idea.highlight.LyngTokenTypes.IDENTIFIER || et == net.sergeych.lyng.idea.highlight.LyngTokenTypes.LABEL) { LyngElementTypes.ENUM_CONSTANT_NAME -> TEXT_TOKENIZER
return IDENTIFIER_TOKENIZER else -> super.getTokenizer(element)
}
if (et == net.sergeych.lyng.idea.highlight.LyngTokenTypes.LINE_COMMENT || et == net.sergeych.lyng.idea.highlight.LyngTokenTypes.BLOCK_COMMENT) {
return COMMENT_TEXT_TOKENIZER
}
if (et == net.sergeych.lyng.idea.highlight.LyngTokenTypes.STRING && settings.spellCheckStringLiterals) {
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 = com.intellij.spellchecker.inspections.IdentifierSplitter.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)
}
} }
} }
} }
@@ -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.
@@ -20,8 +20,6 @@
--> -->
<idea-plugin> <idea-plugin>
<extensions defaultExtensionNs="com.intellij"> <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 --> <!-- Provide text extraction for Lyng PSI so Grazie (bundled Natural Languages) can check content -->
<grazie.textExtractor language="Lyng" <grazie.textExtractor language="Lyng"
implementationClass="net.sergeych.lyng.idea.grazie.LyngTextExtractor"/> 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"); ~ 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,8 +21,6 @@
--> -->
<idea-plugin> <idea-plugin>
<extensions defaultExtensionNs="com.intellij"> <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 --> <!-- Provide text extraction for Lyng PSI so Grazie can actually check content -->
<grazie.textExtractor language="Lyng" <grazie.textExtractor language="Lyng"
implementationClass="net.sergeych.lyng.idea.grazie.LyngTextExtractor"/> implementationClass="net.sergeych.lyng.idea.grazie.LyngTextExtractor"/>
@@ -57,9 +57,6 @@
<!-- External annotator for semantic highlighting --> <!-- External annotator for semantic highlighting -->
<externalAnnotator language="Lyng" implementationClass="net.sergeych.lyng.idea.annotators.LyngExternalAnnotator"/> <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 --> <!-- Quick documentation provider bound to Lyng language -->
<lang.documentationProvider language="Lyng" implementationClass="net.sergeych.lyng.idea.docs.LyngDocumentationProvider"/> <lang.documentationProvider language="Lyng" implementationClass="net.sergeych.lyng.idea.docs.LyngDocumentationProvider"/>
@@ -105,5 +102,15 @@
</extensions> </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> </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"); ~ 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.
@@ -22,8 +22,7 @@
--> -->
<idea-plugin> <idea-plugin>
<extensions defaultExtensionNs="com.intellij"> <extensions defaultExtensionNs="com.intellij">
<!-- Spellchecker strategy: identifiers + comments; literals configurable, skipping printf-like specs -->
<spellchecker.support language="Lyng" <spellchecker.support language="Lyng"
implementationClass="net.sergeych.lyng.idea.spell.LyngSpellcheckingStrategy"/> implementationClass="net.sergeych.lyng.idea.spell.LyngSpellcheckingStrategy"/>
</extensions> </extensions>
</idea-plugin> </idea-plugin>
+1 -1
View File
@@ -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.2.0-SNAPSHOT" version = "1.2.0"
// 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
@@ -1881,6 +1881,7 @@ class Compiler(
pendingDeclStart = null pendingDeclStart = null
// so far only simplest enums: // so far only simplest enums:
val names = mutableListOf<String>() val names = mutableListOf<String>()
val positions = mutableListOf<Pos>()
// skip '{' // skip '{'
cc.skipTokenOfType(Token.Type.LBRACE) cc.skipTokenOfType(Token.Type.LBRACE)
@@ -1889,6 +1890,7 @@ class Compiler(
when (t.type) { when (t.type) {
Token.Type.ID -> { Token.Type.ID -> {
names += t.value names += t.value
positions += t.pos
val t1 = cc.nextNonWhitespace() val t1 = cc.nextNonWhitespace()
when (t1.type) { when (t1.type) {
Token.Type.COMMA -> Token.Type.COMMA ->
@@ -1912,7 +1914,8 @@ class Compiler(
entries = names, entries = names,
doc = doc, doc = doc,
nameStart = nameToken.pos, nameStart = nameToken.pos,
isExtern = isExtern isExtern = isExtern,
entryPositions = positions
) )
) )
@@ -42,7 +42,7 @@ private val fallbackKeywordIds = setOf(
"and", "or", "not", "and", "or", "not",
// declarations & modifiers // declarations & modifiers
"fun", "fn", "class", "interface", "enum", "val", "var", "import", "package", "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", "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",
@@ -205,6 +205,7 @@ data class MiniEnumDecl(
override val nameStart: Pos, override val nameStart: Pos,
override val isExtern: Boolean = false, override val isExtern: Boolean = false,
override val isStatic: Boolean = false, override val isStatic: Boolean = false,
val entryPositions: List<Pos> = emptyList()
) : MiniDecl ) : MiniDecl
data class MiniCtorField( data class MiniCtorField(
@@ -72,10 +72,11 @@ open class ObjException(
val l = getStackTrace().list val l = getStackTrace().list
return buildString { return buildString {
append(message.value) append(message.value)
for( t in l) for (t in l)
append("\n\tat ${t.toString(scope)}") append("\n\tat ${t.toString(scope)}")
} }
} }
override suspend fun defaultToString(scope: Scope): ObjString { override suspend fun defaultToString(scope: Scope): ObjString {
val at = getStackTrace().list.firstOrNull()?.toString(scope) val at = getStackTrace().list.firstOrNull()?.toString(scope)
?: ObjString("(unknown)") ?: ObjString("(unknown)")
@@ -100,21 +101,23 @@ open class ObjException(
while (s != null) { while (s != null) {
val pos = s.pos val pos = s.pos
if (pos != lastPos && !pos.currentLine.isEmpty()) { if (pos != lastPos && !pos.currentLine.isEmpty()) {
if (maybeCls != null) { if( (lastPos == null || (lastPos.source != pos.source || lastPos.line != pos.line)) ) {
result.list += maybeCls.callWithArgs( if (maybeCls != null) {
scope, result.list += maybeCls.callWithArgs(
pos.source.objSourceName, scope,
ObjInt(pos.line.toLong()), pos.source.objSourceName,
ObjInt(pos.column.toLong()), ObjInt(pos.line.toLong()),
ObjString(pos.currentLine) ObjInt(pos.column.toLong()),
) ObjString(pos.currentLine)
} else { )
// Fallback textual entry if StackTraceEntry class is not available in this scope } else {
result.list += ObjString("${pos.source.objSourceName}:${pos.line}:${pos.column}: ${pos.currentLine}") // 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 s = s.parent
lastPos = pos
} }
return result return result
} }
@@ -339,8 +342,8 @@ fun Obj.isLyngException(): Boolean = isInstanceOf("Exception")
/** /**
* Get the exception message. * Get the exception message.
*/ */
suspend fun Obj.getLyngExceptionMessage(scope: Scope?=null): String { suspend fun Obj.getLyngExceptionMessage(scope: Scope? = null): String {
require( this.isLyngException() ) require(this.isLyngException())
val s = scope ?: Script.newScope() val s = scope ?: Script.newScope()
return invokeInstanceMethod(s, "message").toString(s).value return invokeInstanceMethod(s, "message").toString(s).value
} }
@@ -356,18 +359,18 @@ suspend fun Obj.getLyngExceptionMessage(scope: Scope?=null): String {
* The stack trace details each frame using indentation for clarity. * The stack trace details each frame using indentation for clarity.
* @throws IllegalArgumentException if the object is not a Lyng exception. * @throws IllegalArgumentException if the object is not a Lyng exception.
*/ */
suspend fun Obj.getLyngExceptionMessageWithStackTrace(scope: Scope?=null): String { suspend fun Obj.getLyngExceptionMessageWithStackTrace(scope: Scope? = null,showDetails:Boolean=true): String {
require( this.isLyngException() ) require(this.isLyngException())
val s = scope ?: Script.newScope() val s = scope ?: Script.newScope()
val msg = getLyngExceptionMessage(s) val msg = getLyngExceptionMessage(s)
val trace = getLyngExceptionStackTrace(s) val trace = getLyngExceptionStackTrace(s)
var at = "unknown" var at = "unknown"
val stack = if( !trace.list.isEmpty() ) { // var firstLine = true
val stack = if (!trace.list.isEmpty()) {
val first = trace.list[0] val first = trace.list[0]
at = (first.readField(s, "at").value as ObjString).value at = (first.readField(s, "at").value as ObjString).value
"\n" + trace.list.map { " at " + it.toString(s).value }.joinToString("\n") "\n" + trace.list.map { " at " + it.toString(s).value }.joinToString("\n")
} } else ""
else ""
return "$at: $msg$stack" return "$at: $msg$stack"
} }
@@ -392,7 +395,7 @@ suspend fun Obj.getLyngExceptionString(scope: Scope): String =
/** /**
* Rethrow this object as a Kotlin [ExecutionError] if it's an exception. * 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() if (this is ObjException) raise()
val sc = scope ?: Script.newScope() val sc = scope ?: Script.newScope()
val msg = getLyngExceptionMessage(sc) val msg = getLyngExceptionMessage(sc)
@@ -79,6 +79,14 @@ data class ObjString(val value: String) : Obj() {
} }
} }
override suspend fun mul(scope: Scope, other: Obj): Obj {
var times = other.toInt()
if( times < 0 ) scope.raiseIllegalArgument("negative string repetitions")
return ObjString( buildString {
while( times-- > 0 ) append(value)
})
}
override fun hashCode(): Int { override fun hashCode(): Int {
return value.hashCode() return value.hashCode()
} }
@@ -168,6 +168,7 @@ class MiniAstTest {
assertNotNull(ed.doc) assertNotNull(ed.doc)
assertTrue(ed.doc.raw.contains("Enum E docs")) assertTrue(ed.doc.raw.contains("Enum E docs"))
assertEquals(listOf("A", "B", "C"), ed.entries) assertEquals(listOf("A", "B", "C"), ed.entries)
assertEquals(3, ed.entryPositions.size)
assertEquals("E", ed.name) assertEquals("E", ed.name)
} }
@@ -4160,6 +4160,14 @@ class ScriptTest {
) )
} }
@Test
fun testStringMul() = runTest {
eval("""
assertEquals("hellohello", "hello"*2)
assertEquals("", "hello"*0)
""".trimIndent())
}
@Test @Test
fun testLogicalNot() = runTest { fun testLogicalNot() = runTest {
eval( eval(
@@ -4672,6 +4680,29 @@ class ScriptTest {
// source name, in our case, is is "tc2": // source name, in our case, is is "tc2":
assertContains(x1.message!!, "tc2") assertContains(x1.message!!, "tc2")
} }
@Test
fun testFilterStackTrace() = runTest {
var x = try {
evalNamed( "tc1","""
fun f2() = throw IllegalArgumentException("test3")
fun f1() = f2()
f1()
""".trimIndent())
fail("this should throw")
}
catch(x: ExecutionError) {
x
}
assertEquals("""
tc1:1:12: test3
at tc1:1:12: fun f2() = throw IllegalArgumentException("test3")
at tc1:2:12: fun f1() = f2()
at tc1:3:1: f1()
""".trimIndent(),x.errorObject.getLyngExceptionMessageWithStackTrace())
}
@Test @Test
fun testLyngToKotlinExceptionHelpers() = runTest { fun testLyngToKotlinExceptionHelpers() = runTest {
var x = evalNamed( "tc1",""" var x = evalNamed( "tc1","""
+3 -7
View File
@@ -39,7 +39,7 @@ fun Iterable.filter(predicate) {
} }
/* /*
Count all items in this iterable for which predicate return true Count all items in this iterable for which predicate returns true
*/ */
fun Iterable.count(predicate): Int { fun Iterable.count(predicate): Int {
var hits = 0 var hits = 0
@@ -266,12 +266,8 @@ class StackTraceEntry(
/* Print this exception and its stack trace to standard output. */ /* Print this exception and its stack trace to standard output. */
fun Exception.printStackTrace() { fun Exception.printStackTrace() {
println(this) println(this)
var lastEntry = null for( entry in stackTrace )
for( entry in stackTrace ) { println("\tat "+entry.toString())
if( lastEntry == null || lastEntry !is StackTraceEntry || lastEntry.line != entry.line )
println("\tat "+entry.toString())
lastEntry = entry
}
} }
/* Compile this string into a regular expression. */ /* Compile this string into a regular expression. */
+1 -1
View File
@@ -329,7 +329,7 @@
<!-- Top-left version ribbon --> <!-- Top-left version ribbon -->
<div class="corner-ribbon bg-danger text-white"> <div class="corner-ribbon bg-danger text-white">
<span style="margin-left: -5em"> <span style="margin-left: -5em">
v1.2.0-SNAPSHOT v1.2.0!
</span> </span>
</div> </div>
<!-- Fixed top navbar for the whole site --> <!-- Fixed top navbar for the whole site -->