Support BAST imports inside domains

Imports can now appear both at root level and inside domains:
  domain MyApp is {
    import "shared.bast"
    context Users is { ... }
  }

Changes:
- Added BASTImport to DomainContents type
- Moved bastImport parser rule to CommonParser (shared)
- Added bastImport to domainDefinitions in DomainParser
- Updated BASTLoader to recursively process domain contents
- Added test for imports inside domains

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

Author: reidspencer

bast/SESSION_HANDOFF.md

@@ -76,16 +76,22 @@ Phase 3 (serialization/deserialization) is fully working. Phase 4 (import integr
 - `bast/jvm/src/test/scala/com/ossuminc/riddl/bast/BASTLoaderTest.scala`
 
 #### Step 2: Support Import in Domains
-**Status**: PENDING (NEXT)
+**Status**: COMPLETE ✅
 
-**Changes needed:**
-- Add `BASTImport` to `DomainContents` type in AST.scala
-- Add `bastImport` parser rule to domain content parsing
-- Update domain parser to include `bastImport` in content rules
+**Changes made:**
+- Added `BASTImport` to `DomainContents` type in AST.scala
+- Moved `bastImport` parser rule to CommonParser (shared)
+- Added `bastImport` to `domainDefinitions` in DomainParser
+- Updated BASTLoader to recursively process domains
+- Added test for imports inside domains
 
-**Files to modify:**
+**Files modified:**
 - `language/shared/src/main/scala/com/ossuminc/riddl/language/AST.scala`
+- `language/shared/src/main/scala/com/ossuminc/riddl/language/parsing/CommonParser.scala`
+- `language/shared/src/main/scala/com/ossuminc/riddl/language/parsing/RootParser.scala`
 - `language/shared/src/main/scala/com/ossuminc/riddl/language/parsing/DomainParser.scala`
+- `bast/shared/src/main/scala/com/ossuminc/riddl/bast/BASTLoader.scala`
+- `bast/jvm/src/test/scala/com/ossuminc/riddl/bast/BASTLoaderTest.scala`
 
 #### Step 3: Update BASTLoader
 **Status**: COMPLETE ✅ (done as part of Step 1)
@@ -127,8 +133,8 @@ Phase 3 (serialization/deserialization) is fully working. Phase 4 (import integr
 | BASTWriterSpec | 7 | ✅ All passing |
 | BASTRoundTripTest | 3 | ✅ All passing |
 | BASTPerformanceTest | 4 | ✅ All passing |
-| BASTLoaderTest | 3 | ✅ All passing |
-| **Total** | **17** | ✅ **All passing** |
+| BASTLoaderTest | 4 | ✅ All passing |
+| **Total** | **18** | ✅ **All passing** |
 
 ---
 

bast/jvm/src/test/scala/com/ossuminc/riddl/bast/BASTLoaderTest.scala

@@ -210,5 +210,82 @@ class BASTLoaderTest extends AnyWordSpec {
           fail("Failed to parse source RIDDL files")
       }
     }
+
+    "load imports inside domains" in { (td: TestData) =>
+      // Create a RIDDL source with shared types
+      val sharedRiddl = """domain SharedTypes is {
+                          |  type UserId is UUID
+                          |  type Email is String
+                          |  briefly "Shared type definitions"
+                          |}
+                          |""".stripMargin
+
+      // Parse and convert to BAST
+      val sharedInput = RiddlParserInput(sharedRiddl, "test-shared")
+      val sharedResult = TopLevelParser.parseInput(sharedInput, withVerboseFailures = true)
+
+      sharedResult match {
+        case Left(messages) =>
+          fail(s"Shared parse failed: ${messages.format}")
+
+        case Right(sharedRoot: Root) =>
+          // Write to BAST
+          val passInput = PassInput(sharedRoot)
+          val writerResult = Pass.runThesePasses(passInput, Seq(BASTWriter.creator()))
+          val output = writerResult.outputOf[BASTOutput](BASTWriter.name).get
+
+          val tempDir = Files.createTempDirectory("bast-domain-import-test")
+          val bastFile = tempDir.resolve("shared.bast")
+          Files.write(bastFile, output.bytes)
+
+          try {
+            // Create a RIDDL file with import INSIDE a domain
+            val riddlContent = s"""domain MyApp is {
+                                  |  import "${bastFile.toAbsolutePath}"
+                                  |
+                                  |  context Users is {
+                                  |    briefly "User management"
+                                  |  }
+                                  |  briefly "Main application domain"
+                                  |}
+                                  |""".stripMargin
+
+            val rpi = RiddlParserInput(riddlContent, "test-domain-import")
+            val parseResult = TopLevelParser.parseInput(rpi, withVerboseFailures = true)
+
+            parseResult match {
+              case Left(messages) =>
+                fail(s"Parse failed: ${messages.format}")
+
+              case Right(parsedRoot: Root) =>
+                // Verify we can find the BASTImport inside the domain
+                val imports = BASTLoader.getImports(parsedRoot)
+                assert(imports.size == 1, s"Expected 1 import, got ${imports.size}")
+
+                val bastImport = imports.head
+                assert(bastImport.contents.isEmpty, "BASTImport should be empty before loading")
+
+                // Load imports (including those inside domains)
+                val baseURL = URL.fromCwdPath(".")
+                val loadResult = BASTLoader.loadImports(parsedRoot, baseURL)
+
+                assert(loadResult.failedCount == 0,
+                  s"Expected 0 failed: ${loadResult.messages.map(_.format).mkString("; ")}")
+                assert(loadResult.loadedCount == 1, s"Expected 1 loaded, got ${loadResult.loadedCount}")
+
+                // Verify contents were populated
+                assert(bastImport.contents.nonEmpty, "BASTImport should have contents after loading")
+
+                // Verify the SharedTypes domain was loaded
+                val loadedDomains = bastImport.contents.toSeq.collect { case d: Domain => d }
+                assert(loadedDomains.exists(_.id.value == "SharedTypes"),
+                  "Should find SharedTypes domain in loaded contents")
+            }
+          } finally {
+            Files.deleteIfExists(bastFile)
+            Files.deleteIfExists(tempDir)
+          }
+      }
+    }
   }
 }

bast/shared/src/main/scala/com/ossuminc/riddl/bast/BASTLoader.scala

@@ -19,7 +19,8 @@ import scala.util.{Failure, Success, Try}
 /** Utility for loading BAST imports.
   *
   * This loads BAST files referenced by BASTImport nodes and populates their
-  * contents field with the loaded Nebula contents.
+  * contents field with the loaded Nebula contents. Imports can appear at the
+  * root level or inside domains.
   */
 object BASTLoader {
 
@@ -30,10 +31,11 @@ object BASTLoader {
     messages: Messages
   )
 
-  /** Load all BAST imports in a Root.
+  /** Load all BAST imports in a Root, including those inside domains.
     *
-    * Finds all BASTImport nodes in the Root and loads the referenced BAST files,
-    * populating each BASTImport's contents field with the loaded Nebula contents.
+    * Finds all BASTImport nodes in the Root and its domains, loads the referenced
+    * BAST files, and populates each BASTImport's contents field with the loaded
+    * Nebula contents.
     *
     * @param root The Root containing BASTImport nodes to load
     * @param baseURL The base URL for resolving relative BAST file paths
@@ -45,26 +47,33 @@ object BASTLoader {
     var loaded = 0
     var failed = 0
 
-    root.contents.foreach {
-      case bi: BASTImport =>
-        loadSingleImport(bi, baseURL) match {
-          case Right(nebula) =>
-            // Copy Nebula contents into BASTImport contents
-            nebula.contents.foreach { item =>
-              bi.contents.append(item)
-            }
-            loaded += 1
-          case Left(error) =>
-            msgs += Messages.Message(
-              bi.loc,
-              s"Failed to load BAST import '${bi.path.s}': $error",
-              Messages.Error
-            )
-            failed += 1
-        }
-      case _ => () // Not a BASTImport, skip
+    def loadImport(bi: BASTImport): Unit = {
+      loadSingleImport(bi, baseURL) match {
+        case Right(nebula) =>
+          // Copy Nebula contents into BASTImport contents
+          nebula.contents.foreach { item =>
+            bi.contents.append(item)
+          }
+          loaded += 1
+        case Left(error) =>
+          msgs += Messages.Message(
+            bi.loc,
+            s"Failed to load BAST import '${bi.path.s}': $error",
+            Messages.Error
+          )
+          failed += 1
+      }
     }
 
+    def processContents[T <: RiddlValue](contents: Contents[T]): Unit = {
+      contents.foreach {
+        case bi: BASTImport => loadImport(bi)
+        case d: Domain => processContents(d.contents)
+        case _ => () // Not a BASTImport or Domain, skip
+      }
+    }
+
+    processContents(root.contents)
     LoadResult(loaded, failed, msgs.toList)
   }
 
@@ -108,20 +117,35 @@ object BASTLoader {
     * @return true if there are BASTImport nodes with empty contents
     */
   def hasUnloadedImports(root: Root): Boolean = {
-    root.contents.toSeq.exists {
-      case bi: BASTImport => bi.contents.isEmpty
-      case _ => false
+    var found = false
+    def checkContents[T <: RiddlValue](contents: Contents[T]): Unit = {
+      if !found then
+        contents.foreach {
+          case bi: BASTImport => if bi.contents.isEmpty then found = true
+          case d: Domain => checkContents(d.contents)
+          case _ => ()
+        }
+      end if
     }
+    checkContents(root.contents)
+    found
   }
 
-  /** Get all BASTImport nodes from a Root.
+  /** Get all BASTImport nodes from a Root, including those inside domains.
     *
     * @param root The Root to search
     * @return Sequence of BASTImport nodes
     */
   def getImports(root: Root): Seq[BASTImport] = {
-    root.contents.toSeq.collect {
-      case bi: BASTImport => bi
+    val result = mutable.ListBuffer.empty[BASTImport]
+    def collectFromContents[T <: RiddlValue](contents: Contents[T]): Unit = {
+      contents.foreach {
+        case bi: BASTImport => result += bi
+        case d: Domain => collectFromContents(d.contents)
+        case _ => ()
+      }
     }
+    collectFromContents(root.contents)
+    result.toSeq
   }
 }

language/shared/src/main/scala/com/ossuminc/riddl/language/AST.scala

@@ -816,8 +816,8 @@ object AST:
   /** Type of definitions that occur in a [[Domain]] without [[Include]] */
   type OccursInDomain = OccursInVitalDefinition | Author | Context | Domain | User | Epic | Saga
 
-  /** Type of definitions that occur in a [[Domain]] with [[Include]] */
-  type DomainContents = OccursInDomain | Include[OccursInDomain]
+  /** Type of definitions that occur in a [[Domain]] with [[Include]] and [[BASTImport]] */
+  type DomainContents = OccursInDomain | Include[OccursInDomain] | BASTImport
 
   /** Type of definitions that occur in a [[Context]] without [[Include]] */
   type OccursInContext = OccursInProcessor | Entity | Adaptor | Group | Saga | Projector |

language/shared/src/main/scala/com/ossuminc/riddl/language/parsing/CommonParser.scala

@@ -67,6 +67,14 @@ private[parsing] trait CommonParser(using pc: PlatformContext)
     }
   }
 
+  /** Parse a BAST import statement: `import "path/to/file.bast"` */
+  def bastImport[u: P]: P[BASTImport] = {
+    P(Index ~ Keywords.import_ ~ literalString ~ Index).map {
+      case (start, path, end) =>
+        doBASTImport(at(start, end), path)
+    }
+  }
+
   def undefined[u: P, RT](f: => RT): P[RT] = {
     P(Punctuation.undefinedMark./).map(_ => f)
   }

language/shared/src/main/scala/com/ossuminc/riddl/language/parsing/DomainParser.scala

@@ -33,7 +33,7 @@ private[parsing] trait DomainParser {
   private def domainDefinitions[u: P]: P[Seq[DomainContents]] = {
     P(
       vitalDefinitionContents |
-        author | context | domain | user | epic | saga | importDef | domainInclude | comment
+        author | context | domain | user | epic | saga | importDef | bastImport | domainInclude | comment
     ).asInstanceOf[P[DomainContents]]./.rep(1)
   }
 

language/shared/src/main/scala/com/ossuminc/riddl/language/parsing/RootParser.scala

@@ -20,13 +20,7 @@ trait RootParser { this: ModuleParser & CommonParser & ParsingContext =>
     include[u, RootContents](rootContents(_))
   }
 
-  /** Parse a BAST import statement: `import "path/to/file.bast"` */
-  private def bastImport[u: P]: P[BASTImport] = {
-    P(Index ~ Keywords.import_ ~ literalString ~ Index).map {
-      case (start, path, end) =>
-        doBASTImport(at(start, end), path)
-    }
-  }
+  // bastImport is inherited from CommonParser
 
   private def rootContent[u: P]: P[RootContents] = {
     P(bastImport | moduleContent | module | rootInclude[u]).asInstanceOf[P[RootContents]]