Integrate RiddlLib for annotator, structure view, and navigation

Replace direct parser calls with RiddlLib high-level API methods:
- Annotator: validateString() for full semantic validation with
  parseNebula() fallback for include fragments
- Structure view: getTree() for AST-accurate recursive hierarchy
  with regex fallback for fragment files
- Navigation: getOutline() for AST-accurate go-to-definition
  with regex fallback for fragment files

Also upgrades RIDDL to 1.8.0, sbt-ossuminc to 1.3.2, and
Scala to 3.7.4.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: respencer-ncl

build.sbt

@@ -36,7 +36,7 @@ lazy val riddlIdeaPlugin: Project =
     spdx = "Apache-2.0"
   ).configure(
       With.basic,
-      With.Scala3.configure(version = Some("3.4.3")),
+      With.Scala3.configure(version = Some("3.7.4")),
       With.Scalatest(V.scalatest),
       With.coverage(0),
       With.BuildInfo,
@@ -50,6 +50,7 @@ lazy val riddlIdeaPlugin: Project =
       libraryDependencies ++= Seq(
         Dep.minimalJson,
         Dep.riddlCommands,
+        Dep.riddlLib,
         Dep.junit,
         Dep.opentest4j
       ),

project/Dependencies.scala

@@ -4,7 +4,7 @@ import sbt.*
 object V {
   val lang3 = "3.14.0"
   val opentest4j = "1.3.0"
-  val riddl = "1.0.0"
+  val riddl = "1.8.0"
   val scalatest = "3.2.19"
   val scopt = "4.1.0"
   val slf4j = "2.0.4"
@@ -20,6 +20,7 @@ object Dep {
   }
   val kotlin = "org.jetbrains.kotlin" % "kotlin-stdlib" % "2.0.20"
   val riddlCommands = "com.ossuminc" %% "riddl-commands" % V.riddl
+  val riddlLib = "com.ossuminc" %% "riddl-lib" % V.riddl
   val jbKotlin = "org.jetbrains.kotlin" % "kotlin-stdlib" % "2.0.20"
   val jbAnnotations = "org.jetbrains" % "annotations" % "24.1.0"
 

project/plugins.sbt

@@ -1,7 +1,7 @@
 // GitHub Packages resolver for sbt-ossuminc
 resolvers += "GitHub Packages" at "https://maven.pkg.github.com/ossuminc/sbt-ossuminc"
 
-addSbtPlugin("com.ossuminc" % "sbt-ossuminc" % "1.2.5")
+addSbtPlugin("com.ossuminc" % "sbt-ossuminc" % "1.3.2")
 
 // Note: sbt-idea-plugin is included in sbt-ossuminc 1.2.0 (version 5.0.4)
 

src/main/scala/com/ossuminc/riddl/plugins/idea/annotator/RiddlExternalAnnotator.scala

@@ -11,7 +11,7 @@ import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.util.TextRange
 import com.intellij.psi.PsiFile
 import com.ossuminc.riddl.language.Messages.{Message, Error, Warning, Info, SevereError, MissingWarning, StyleWarning, UsageWarning}
-import com.ossuminc.riddl.language.parsing.{RiddlParserInput, TopLevelParser}
+import com.ossuminc.riddl.RiddlLib
 import com.ossuminc.riddl.utils.{NullLogger, pc}
 
 /** External annotator for RIDDL files.
@@ -36,19 +36,32 @@ class RiddlExternalAnnotator
       hasErrors: Boolean
   ): RiddlAnnotationInfo = collectInformation(file)
 
-  /** Perform the actual annotation work (runs on background thread). */
+  /** Perform the actual annotation work (runs on background thread).
+    *
+    * Uses RiddlLib.validateString() for full semantic validation (parse +
+    * resolution + validation passes). If the document fails to parse as a
+    * complete Root (e.g. it's an include fragment), falls back to
+    * RiddlLib.parseNebula() which tolerates partial definitions.
+    */
   override def doAnnotate(info: RiddlAnnotationInfo): RiddlAnnotationResult =
     if info.text.isEmpty then RiddlAnnotationResult(Seq.empty)
     else
       pc.withLogger(NullLogger()) { _ =>
-        val rpi = RiddlParserInput(info.text, info.filePath)
-        TopLevelParser.parseNebula(rpi) match
-          case Right(_) =>
-            // Parse succeeded, no syntax errors
-            RiddlAnnotationResult(Seq.empty)
-          case Left(messages) =>
-            // Collect error messages
-            RiddlAnnotationResult(messages.toSeq)
+        val vr = RiddlLib.validateString(
+          info.text, info.filePath
+        )(using pc)
+        if vr.parseErrors.isEmpty then
+          // Full validation succeeded — return all messages
+          RiddlAnnotationResult(vr.all)
+        else
+          // Parse as Root failed — try fragment parsing via nebula
+          RiddlLib.parseNebula(
+            info.text, info.filePath
+          )(using pc) match
+            case Right(_) =>
+              RiddlAnnotationResult(Seq.empty)
+            case Left(messages) =>
+              RiddlAnnotationResult(messages.toSeq)
       }
 
   /** Apply the annotations to the editor (runs on UI thread). */

src/main/scala/com/ossuminc/riddl/plugins/idea/navigation/RiddlGotoDeclarationHandler.scala

@@ -10,6 +10,8 @@ import com.intellij.codeInsight.navigation.actions.GotoDeclarationHandler
 import com.intellij.openapi.actionSystem.DataContext
 import com.intellij.openapi.editor.Editor
 import com.intellij.psi.{PsiElement, PsiFile}
+import com.ossuminc.riddl.RiddlLib
+import com.ossuminc.riddl.utils.{NullLogger, pc}
 
 import scala.collection.mutable.ArrayBuffer
 import scala.util.matching.Regex
@@ -72,11 +74,27 @@ class RiddlGotoDeclarationHandler extends GotoDeclarationHandler {
   private def isIdentifierChar(c: Char): Boolean =
     c.isLetterOrDigit || c == '_'
 
-  /** Find all definitions of the given identifier. */
+  /** Find all definitions of the given identifier.
+    *
+    * Tries RiddlLib.getOutline() first for AST-accurate results.
+    * Falls back to regex for fragment files that can't parse as Root.
+    */
   private def findDefinitions(text: String, identifier: String): Seq[(Int, String)] = {
+    pc.withLogger(NullLogger()) { _ =>
+      RiddlLib.getOutline(text, "navigation")(using pc) match
+        case Right(entries) =>
+          entries
+            .filter(_.id == identifier)
+            .map(e => (e.offset, e.kind.toLowerCase))
+        case Left(_) =>
+          findDefinitionsRegex(text, identifier)
+    }
+  }
+
+  /** Regex-based fallback for finding definitions in fragment files. */
+  private def findDefinitionsRegex(text: String, identifier: String): Seq[(Int, String)] = {
     val results = ArrayBuffer[(Int, String)]()
 
-    // Patterns for different definition types
     val patterns: Seq[(String, Regex)] = Seq(
       ("domain", s"""(?m)^\\s*(domain)\\s+($identifier)\\s""".r),
       ("context", s"""(?m)^\\s*(context)\\s+($identifier)\\s""".r),

src/main/scala/com/ossuminc/riddl/plugins/idea/structure/RiddlStructureElements.scala

@@ -10,9 +10,9 @@ import com.intellij.ide.structureView.StructureViewTreeElement
 import com.intellij.ide.util.treeView.smartTree.{SortableTreeElement, TreeElement}
 import com.intellij.navigation.{ItemPresentation, NavigationItem}
 import com.intellij.psi.PsiFile
-import com.ossuminc.riddl.language.parsing.{RiddlParserInput, TopLevelParser}
-import com.ossuminc.riddl.language.At
-import com.ossuminc.riddl.utils.{NullLogger, PlatformContext, pc}
+import com.ossuminc.riddl.RiddlLib
+import com.ossuminc.riddl.passes.TreeNode
+import com.ossuminc.riddl.utils.{NullLogger, pc}
 
 import javax.swing.Icon
 import scala.collection.mutable.ArrayBuffer
@@ -94,12 +94,68 @@ class RiddlDefinitionElement(definition: RiddlDefinition, psiFile: PsiFile)
   override def canNavigateToSource: Boolean = true
 }
 
-/** Parser for extracting RIDDL definitions from source text. */
+/** Parser for extracting RIDDL definitions from source text.
+  *
+  * Tries RiddlLib.getTree() first for AST-accurate structure with full
+  * hierarchy. Falls back to regex-based parsing for fragment files that
+  * can't parse as a complete Root document.
+  */
 object RiddlStructureParser {
 
-  /** Regex patterns for extracting definitions.
-    * Each pattern captures: optional description, keyword, name
+  /** Parse definitions from RIDDL source text.
+    *
+    * Uses RiddlLib.getTree() for accurate, recursive structure when the
+    * text is a valid Root document. Falls back to regex for fragments.
     */
+  def parseDefinitions(text: String): Seq[RiddlDefinition] = {
+    pc.withLogger(NullLogger()) { _ =>
+      RiddlLib.getTree(text, "structure")(using pc) match
+        case Right(treeNodes) =>
+          val mapped = treeNodes.map(node => mapTreeNode(text, node))
+          // Unwrap Root nodes — structure view starts at domain level
+          mapped.flatMap { defn =>
+            if defn.kind == "root" then defn.children
+            else Seq(defn)
+          }
+        case Left(_) =>
+          parseDefinitionsRegex(text)
+    }
+  }
+
+  /** Map a RiddlLib TreeNode to a RiddlDefinition. */
+  private def mapTreeNode(text: String, node: TreeNode): RiddlDefinition = {
+    val endOff = findClosingBrace(text, node.offset)
+    RiddlDefinition(
+      kind = node.kind.toLowerCase,
+      name = node.id,
+      offset = node.offset,
+      endOffset = endOff,
+      children = node.children.map(child => mapTreeNode(text, child))
+    )
+  }
+
+  /** Find the matching closing brace starting from the given position. */
+  private def findClosingBrace(text: String, startPos: Int): Int = {
+    var level = 0
+    var foundOpenBrace = false
+    var i = startPos
+    while i < text.length do {
+      val c = text.charAt(i)
+      if c == '{' then {
+        level += 1
+        foundOpenBrace = true
+      } else if c == '}' then {
+        level -= 1
+        if foundOpenBrace && level == 0 then return i + 1
+      }
+      i += 1
+    }
+    text.length
+  }
+
+  // --- Regex fallback for fragment files ---
+
+  /** Regex patterns for extracting definitions. */
   private val DEFINITION_PATTERNS: Seq[(String, scala.util.matching.Regex)] = Seq(
     ("domain", """(?m)^\s*(domain)\s+(\w+)""".r),
     ("context", """(?m)^\s*(context)\s+(\w+)""".r),
@@ -126,15 +182,10 @@ object RiddlStructureParser {
     ("record", """(?m)^\s*(record)\s+(\w+)""".r)
   )
 
-  /** Parse definitions from RIDDL source text.
-    *
-    * This uses a simplified regex-based approach for structure view.
-    * It extracts top-level and nested definitions without full parsing.
-    */
-  def parseDefinitions(text: String): Seq[RiddlDefinition] = {
+  /** Regex-based fallback for parsing definitions from fragment files. */
+  private[structure] def parseDefinitionsRegex(text: String): Seq[RiddlDefinition] = {
     val allMatches = ArrayBuffer[(String, String, Int, Int)]()
 
-    // Find all definition matches
     DEFINITION_PATTERNS.foreach { case (kind, pattern) =>
       pattern.findAllMatchIn(text).foreach { m =>
         val name = m.group(2)
@@ -144,10 +195,7 @@ object RiddlStructureParser {
       }
     }
 
-    // Sort by position
     val sorted = allMatches.sortBy(_._3).toSeq
-
-    // Build hierarchy based on brace nesting
     buildHierarchy(text, sorted)
   }
 
@@ -158,7 +206,6 @@ object RiddlStructureParser {
   ): Seq[RiddlDefinition] = {
     if definitions.isEmpty then return Seq.empty
 
-    // Calculate nesting level at each definition's position
     def nestingLevel(position: Int): Int = {
       var level = 0
       var i = 0
@@ -170,39 +217,18 @@ object RiddlStructureParser {
       level
     }
 
-    // Find the end of a definition (matching closing brace)
-    def findDefinitionEnd(startPos: Int): Int = {
-      var level = 0
-      var foundOpenBrace = false
-      var i = startPos
-      while i < text.length do {
-        val c = text.charAt(i)
-        if c == '{' then {
-          level += 1
-          foundOpenBrace = true
-        } else if c == '}' then {
-          level -= 1
-          if foundOpenBrace && level == 0 then return i + 1
-        }
-        i += 1
-      }
-      text.length
-    }
-
-    // Build tree structure
     val withLevels = definitions.map { case (kind, name, start, end) =>
-      (kind, name, start, findDefinitionEnd(start), nestingLevel(start))
+      (kind, name, start, findClosingBrace(text, start), nestingLevel(start))
     }
 
-    // Get top-level definitions (level 0)
     val topLevel = withLevels.filter(_._5 == 0)
 
     topLevel.map { case (kind, name, start, end, _) =>
       val children = withLevels
         .filter { case (_, _, childStart, childEnd, level) =>
           level > 0 && childStart > start && childEnd <= end
         }
-        .filter(_._5 == 1) // Only direct children (level 1)
+        .filter(_._5 == 1)
         .map { case (ck, cn, cs, ce, _) =>
           RiddlDefinition(ck, cn, cs, ce)
         }

src/test/scala/com/ossuminc/riddl/plugins/idea/annotator/RiddlExternalAnnotatorSpec.scala

@@ -6,6 +6,7 @@
 
 package com.ossuminc.riddl.plugins.idea.annotator
 
+import com.ossuminc.riddl.language.Messages.{Error, SevereError}
 import org.scalatest.matchers.must.Matchers
 import org.scalatest.wordspec.AnyWordSpec
 
@@ -29,14 +30,19 @@ class RiddlExternalAnnotatorSpec extends AnyWordSpec with Matchers {
       info.filePath mustBe filePath
     }
 
-    "return empty result for valid RIDDL" in {
+    "return no errors for valid RIDDL" in {
       val annotator = new RiddlExternalAnnotator()
       // RIDDL requires at least a ???  placeholder or actual content
       val info = RiddlAnnotationInfo("domain Test is { ??? }", "/test/example.riddl")
 
       val result = annotator.doAnnotate(info)
 
-      result.messages mustBe empty
+      // Full validation may produce MissingWarning/StyleWarning for
+      // minimal models, but should have no Error-level messages
+      val errors = result.messages.filter(m =>
+        m.kind == Error || m.kind == SevereError
+      )
+      errors mustBe empty
     }
 
     "return empty result for empty text" in {
@@ -79,6 +85,43 @@ class RiddlExternalAnnotatorSpec extends AnyWordSpec with Matchers {
 
       val result = annotator.doAnnotate(info)
 
+      // Full validation may produce warnings for minimal models
+      // (missing descriptions, empty metadata, unused types) but
+      // should have no Error-level messages
+      val errors = result.messages.filter(m =>
+        m.kind == Error || m.kind == SevereError
+      )
+      errors mustBe empty
+    }
+
+    "detect semantic errors via full validation" in {
+      val annotator = new RiddlExternalAnnotator()
+      val text =
+        """domain Test is {
+          |  context C is {
+          |    type Ref is reference to UndefinedEntity
+          |  }
+          |}""".stripMargin
+      val info = RiddlAnnotationInfo(text, "/test/example.riddl")
+
+      val result = annotator.doAnnotate(info)
+
+      // Full validation should find unresolvable reference
+      result.messages.nonEmpty mustBe true
+    }
+
+    "handle RIDDL fragments via nebula fallback" in {
+      val annotator = new RiddlExternalAnnotator()
+      // This is a fragment (not a complete Root document)
+      val text =
+        """context TestContext is {
+          |  type UserId is String
+          |}""".stripMargin
+      val info = RiddlAnnotationInfo(text, "/test/fragment.riddl")
+
+      val result = annotator.doAnnotate(info)
+
+      // Fragment should parse OK via nebula fallback
       result.messages mustBe empty
     }
   }