Fixed some issues and cleanup

src/app.nim

@@ -267,6 +267,7 @@ proc registerEditor*(self: App, editor: DocumentEditor): void
 proc unregisterEditor*(self: App, editor: DocumentEditor): void
 proc tryActivateEditor*(self: App, editor: DocumentEditor): void
 proc getActiveEditor*(self: App): Option[DocumentEditor]
+proc getActiveViewEditor*(self: App): Option[DocumentEditor]
 proc getEditorForId*(self: App, id: EditorId): Option[DocumentEditor]
 proc getEditorForPath*(self: App, path: string): Option[DocumentEditor]
 proc getPopupForId*(self: App, id: EditorId): Option[Popup]
@@ -319,6 +320,7 @@ implTrait AppInterface, App:
   registerEditor(void, App, DocumentEditor)
   tryActivateEditor(void, App, DocumentEditor)
   getActiveEditor(Option[DocumentEditor], App)
+  getActiveViewEditor(Option[DocumentEditor], App)
   unregisterEditor(void, App, DocumentEditor)
   getEditorForId(Option[DocumentEditor], App, EditorId)
   getEditorForPath(Option[DocumentEditor], App, string)
@@ -3736,6 +3738,12 @@ proc getActiveEditor*(self: App): Option[DocumentEditor] =
 
   return DocumentEditor.none
 
+proc getActiveViewEditor*(self: App): Option[DocumentEditor] =
+  if self.tryGetCurrentEditorView().getSome(view):
+    return view.editor.some
+
+  return DocumentEditor.none
+
 proc logRootNode*(self: App) {.expose("editor").} =
   let str = self.platform.builder.root.dump(true)
   debug "logRootNode: ", str

src/app_interface.nim

@@ -25,6 +25,7 @@ traitRef AppInterface:
   method unregisterEditor*(self: AppInterface, editor: DocumentEditor): void {.gcsafe, raises: [].}
   method tryActivateEditor*(self: AppInterface, editor: DocumentEditor) {.gcsafe, raises: [].}
   method getActiveEditor*(self: AppInterface): Option[DocumentEditor] {.gcsafe, raises: [].}
+  method getActiveViewEditor*(self: AppInterface): Option[DocumentEditor] {.gcsafe, raises: [].}
   method getEditorForId*(self: AppInterface, id: EditorId): Option[DocumentEditor] {.gcsafe, raises: [].}
   method getEditorForPath*(self: AppInterface, path: string): Option[DocumentEditor] {.gcsafe, raises: [].}
   method getPopupForId*(self: AppInterface, id: EditorId): Option[Popup] {.gcsafe, raises: [].}

src/dispatch_tables.nim

@@ -43,4 +43,4 @@ proc extendActiveDispatchTable*(namespace: string, function: ExposedFunction) =
     if table.namespace == namespace:
       table.functions[function.name] = function
       return
-  addActiveDispatchTable(namespace, [function])
+  addActiveDispatchTable(namespace, [function])

src/language_server_command_line.nim

@@ -37,7 +37,7 @@ method getCompletions*(self: LanguageServerCommandLine, filename: string, locati
 
   var completions: seq[CompletionItem]
   if useActive:
-    let currentNamespace = self.app.getActiveEditor().mapIt(it.getNamespace)
+    let currentNamespace = self.app.getActiveViewEditor().mapIt(it.getNamespace)
     {.gcsafe.}:
       for table in activeDispatchTables.mitems:
         if not table.global and table.namespace.some != currentNamespace:

src/service.nim

@@ -62,14 +62,21 @@ proc initService(self: Services, name: string) {.async.} =
     service.state = Failed
 
 proc addService*(self: Services, name: string, service: Service, dependencies: seq[string] = @[]) =
-  log lvlInfo, &"addService {name}"
+  log lvlInfo, &"addService {name}, dependencies: {dependencies}"
   service.services = self
   self.registered[name] = service
   service.state = Registered
 
+  var dependencies = dependencies
+  for name in self.running.keys:
+    let idx = dependencies.find(name)
+    if idx != -1:
+      dependencies.removeSwap(idx)
+
   if dependencies.len == 0:
     asyncSpawn self.initService(name)
   else:
+    log lvlInfo, &"addService {name}, remaining dependencies: {dependencies}"
     self.dependencies[name] = dependencies
 
 proc getService*(self: Services, T: typedesc): Option[T] {.gcsafe, raises: [].} =
@@ -96,26 +103,19 @@ proc getServiceAsync*(self: Services, T: typedesc): Future[Option[T]] {.gcsafe,
 proc addService*[T: Service](self: Services, service: T) {.gcsafe, raises: [].} =
   self.addService(T.serviceName, service)
 
-# func addBuiltinServiceImpl(T: NimNode, name: static string, names: static seq[string], dependencies: varargs[typed]) =
-#   echo "addBuiltinService ", T.treeRepr, ", ", dependencies.treeRepr
-#   builtinServices.add nnkTupleExpr.newTree(T, genAst(T, T.serviceName))
-
-macro addBuiltinServiceImpl(T: typed, name: static string, names: static seq[string], dependencies: varargs[typed]) =
-  echo "addBuiltinService ", T.treeRepr, ", ", dependencies.treeRepr
+macro addBuiltinServiceImpl(T: typed, name: static string, dependencies: static seq[string]) =
   var dependencyNames = nnkBracket.newTree()
-  for n in names:
+  for n in dependencies:
     dependencyNames.add n.newLit
 
   builtinServices.add nnkBracket.newTree(T, newLit(name), nnkPrefix.newTree(ident"@", dependencyNames))
 
 macro addBuiltinService*(T: typed, dependencies: varargs[typed]) =
-  echo "addBuiltinService ", T.treeRepr, ", ", dependencies.treeRepr
   var dependencyNames = nnkPrefix.newTree(ident"@", nnkBracket.newTree())
   for d in dependencies:
-    dependencyNames.add genAst(d, d.serviceName)
-  echo dependencyNames.treeRepr
-  result = genAst(T, dependencies):
-    addBuiltinServiceImpl(T, T.serviceName, @[], dependencies)
+    dependencyNames[1].add genAst(d, d.serviceName)
+  result = genAst(T, dependencyNames):
+    addBuiltinServiceImpl(T, T.serviceName, dependencyNames)
 
 macro addBuiltinServices*(services: Services) =
   result = nnkStmtList.newTree()
@@ -124,7 +124,6 @@ macro addBuiltinServices*(services: Services) =
     let T = serviceInfo[0]
     let name = serviceInfo[1]
     let dependencies = serviceInfo[2]
-    echo serviceInfo.treeRepr
     result.add genAst(services, T, name, dependencies, services.addService(name, T(), dependencies))
 
   echo result.repr

src/text/language/debugger.nim

@@ -68,6 +68,16 @@ type
     scopes*: Table[(ThreadId, FrameId), Scopes]
     variables*: Table[(ThreadId, FrameId, VariablesReference), Variables]
 
+type
+  DebuggerService = ref object of Service
+
+func serviceName*(_: typedesc[DebuggerService]): string = "DebuggerService"
+addBuiltinService(DebuggerService)
+
+method init*(self: DebuggerService): Future[Result[void, ref CatchableError]] {.async: (raises: []).} =
+  log lvlInfo, &"DebuggerService.init"
+  return ok()
+
 proc applyBreakpointSignsToEditor(self: Debugger, editor: TextDocumentEditor)
 proc handleAction(self: Debugger, action: string, arg: string): EventResponse
 proc updateVariables(self: Debugger, variablesReference: VariablesReference, maxDepth: int) {.async.}