referenced interfaces

1 files changed, 22 insertions, 9 deletions

diff --git a/tools/Scanner/Processor.lean b/tools/Scanner/Processor.lean
index fad25bc..88853a6 100644
--- a/tools/Scanner/Processor.lean
+++ b/tools/Scanner/Processor.lean
@@ -11,9 +11,10 @@ private abbrev InterfaceMap := Std.TreeMap String InterfaceInfo
 
 private structure Context where
   interfaces : InterfaceMap
-  currentInterface : Identifier
+  currentInterface : Client.InterfaceRef
+  referencedInterfaces : Array Client.InterfaceRef
 
-private abbrev Processor : Type → Type := ReaderT Context (Except String)
+private abbrev Processor : Type → Type := StateT Context (Except String)
 
 private def processEnumEntry (raw : Raw.EnumEntryDesc) : Processor Client.EnumEntryDesc := do
   return {
@@ -25,21 +26,24 @@ private def processEnumEntry (raw : Raw.EnumEntryDesc) : Processor Client.EnumEn
   }
 
 private def interfaceInfo (name : String) : Processor InterfaceInfo := do
-  match (← read).interfaces.get? name with
+  match (← get).interfaces.get? name with
   | .some info => pure info
   | .none => .error s!"Unable to find referenced interface {name}"
 
 private def resolveInterface (name : String) : Processor Client.InterfaceRef := do
   let info ← interfaceInfo name
-  return {
+  let ref := {
     moduleName := info.moduleName
     typeName := name
   }
+  let old ← get
+  set { old with referencedInterfaces := old.referencedInterfaces ++ #[ref] }
+  return ref
 
 private def resolveEnum (name : String) : Processor Client.EnumRef := do
   let (interface, enum) ←
     match (name.split ".").toArray with
-    | #[enum]            => pure ((← read).currentInterface, enum.toString)
+    | #[enum]            => pure ((← get).currentInterface.typeName, enum.toString)
     | #[interface, enum] => pure (interface.toString, enum.toString)
     | _                  => throw s!"Malformed enum reference {name}"
   let info ← interfaceInfo interface
@@ -107,13 +111,21 @@ private def processEvent (raw : Raw.MessageDesc) : Processor Client.EventDesc :=
   }
 
 private def processInterface (raw : Raw.InterfaceDesc) : Processor Client.InterfaceDesc := do
+  let requests ← raw.requests.mapM processRequest
+  let events ← raw.events.mapM processEvent
+  let state ← get
+  let referencedInterfaces := state.referencedInterfaces ++ #[state.currentInterface]
   return {
     name := raw.name
     version := raw.version
     description := raw.description
     enums := ← raw.enums.mapM processEnum
-    requests := ← raw.requests.mapM processRequest
-    events := ← raw.events.mapM processEvent
+    requests := requests
+    events := events
+    referencedInterfaces := referencedInterfaces
+      |>.toList
+      |>.eraseDups
+      |>.toArray
   }
 
 private def processProtocol (interfaces : InterfaceMap) (raw : Raw.ProtocolDesc) : Except String Client.ProtocolDesc := do
@@ -122,9 +134,10 @@ private def processProtocol (interfaces : InterfaceMap) (raw : Raw.ProtocolDesc)
     copyright := raw.copyright
     description := raw.description
     interfaces := ← raw.interfaces.mapM
-      fun iface ↦ (processInterface iface).run {
+      fun iface ↦ (processInterface iface).run' {
         interfaces := interfaces
-        currentInterface := iface.name
+        currentInterface := { moduleName := raw.name, typeName := iface.name }
+        referencedInterfaces := #[]
       }
   }