[ test ] Trying to figure out what happened on Windows

Author: banacorn

.github/workflows/test.yml

@@ -21,8 +21,10 @@ jobs:
     runs-on: ${{ matrix.os }} 
     strategy:
       matrix:
-        os: [windows-latest, ubuntu-latest, macos-latest]
-        agda: ["Agda-2.6.3", "Agda-2.6.4", "Agda-2.7.0"]
+        # os: [windows-latest, ubuntu-latest, macos-latest]
+        os: [windows-latest]
+        # agda: ["Agda-2.6.3", "Agda-2.6.4", "Agda-2.7.0"]
+        agda: ["Agda-2.7.0"]
       fail-fast: false
 
     # Steps represent a sequence of tasks that will be executed as part of the job

lib/js/src/Connection/Connection.bs.js

@@ -109,39 +109,43 @@ module Module: Module = {
   }
 
   // see if it's a Agda executable or a language server
-  let probeFilepath = async path =>
+  let probeFilepath = async path => {
+    Js.log("[ LOG ][ Connection.probeFilepath ] Input path: " ++ path)
     switch URI.parse(path) {
     | Connection__URI.LspURI(_) => Error(Error.Probe.CannotHandleURLsAtTheMoment)
     | FileURI(_, vscodeUri) =>
-      let path = VSCode.Uri.fsPath(vscodeUri)
-      let result = await Connection__Process__Exec.run(path, ["--version"], ~timeout=3000)
+      let fsPath = VSCode.Uri.fsPath(vscodeUri)
+      Js.log("[ LOG ][ Connection.probeFilepath ] VSCode.Uri.fsPath result: " ++ fsPath)
+      let result = await Connection__Process__Exec.run(fsPath, ["--version"], ~timeout=3000)
       switch result {
       | Ok(output) =>
         // try Agda
         switch String.match(output, %re("/Agda version (.*)/")) {
-        | Some([_, Some(version)]) => Ok(path, Ok(version))
+        | Some([_, Some(version)]) => Ok(fsPath, Ok(version))
         | _ =>
           // try ALS
           switch String.match(output, %re("/Agda v(.*) Language Server v(.*)/")) {
           | Some([_, Some(agdaVersion), Some(alsVersion)]) =>
-            let lspOptions = switch await checkForPrebuiltDataDirectory(path) {
+            let lspOptions = switch await checkForPrebuiltDataDirectory(fsPath) {
             | Some(assetPath) =>
               let env = Dict.fromArray([("Agda_datadir", assetPath)])
               Some({Connection__Protocol__LSP__Binding.env: env})
             | None => None
             }
-            Ok(path, Error(alsVersion, agdaVersion, lspOptions))
+            Ok(fsPath, Error(alsVersion, agdaVersion, lspOptions))
           | _ => Error(Error.Probe.NotAgdaOrALS(output))
           }
         }
       | Error(error) => Error(Error.Probe.CannotDetermineAgdaOrALS(error))
       }
-    }
+    }}
 
   let makeWithRawPath = async (rawpath: string): result<t, Error.Establish.t> => {
+    Js.log("[ LOG ][ Connection.makeWithRawPath ] Input rawpath: " ++ rawpath)
     switch await probeFilepath(rawpath) {
     | Ok(path, Ok(agdaVersion)) =>
-      let connection = await Agda.make(rawpath, agdaVersion)
+      Js.log("[ LOG ][ Connection.makeWithRawPath ] Passing to Agda.make: " ++ path)
+      let connection = await Agda.make(path, agdaVersion)
       Ok(Agda(connection, path, agdaVersion))
     | Ok(path, Error(alsVersion, agdaVersion, lspOptions)) =>
       switch await ALS.make(
@@ -322,9 +326,11 @@ module Module: Module = {
   }
 
   let sendRequest = async (connection, document, request, handler) => {
+    Js.log("[ LOG ] Sending request: " ++ Request.toString(request))
     // encode the Request to some string
     let encodeRequest = (document, version) => {
       let filepath = document->VSCode.TextDocument.fileName->Parser.filepath
+      Js.log("[ LOG ] original filepath: " ++ filepath)
       let libraryPath = Config.getLibraryPath()
       let highlightingMethod = Config.Highlighting.getHighlightingMethod()
       let backend = Config.getBackend()

lib/js/src/Connection/Endpoint/Connection__Endpoint__Agda.bs.js

@@ -89,6 +89,7 @@ module Module: Module = {
   }
 
   let make = async (path, version) => {
+    Js.log("[ LOG ][ Agda.make ] Received path: " ++ path)
     let args = Array.concat(["--interaction"], Config.Connection.getCommandLineOptions())
     let conn = {
       process: Process.make(path, args),

lib/js/src/Connection/Transport/Connection__Transport__Process.bs.js

@@ -58,6 +58,7 @@ module Module: Module = {
   }
 
   let make = (path, args) => {
+    Js.log("[ LOG ][ Process.make ] About to spawn process with path: " ++ path)
     let chan = Chan.make()
     let stderr = ref("")
     // spawn the child process
@@ -69,6 +70,7 @@ module Module: Module = {
     ->Option.forEach(stream =>
       stream
       ->NodeJs.Stream.onData(chunk => {
+        Js.log("[ LOG ][ " ++ path ++ "] Process stdout: " ++ NodeJs.Buffer.toString(chunk))
         chan->Chan.emit(Stdout(NodeJs.Buffer.toString(chunk)))
       })
       ->ignore
@@ -80,6 +82,7 @@ module Module: Module = {
     ->Option.forEach(stream =>
       stream
       ->NodeJs.Stream.onData(chunk => {
+        Js.log("[ LOG ][ " ++ path ++ "] Process stderr: " ++ NodeJs.Buffer.toString(chunk))
         chan->Chan.emit(Stderr(NodeJs.Buffer.toString(chunk)))
         // store the latest message from stderr
         stderr := stderr.contents ++ NodeJs.Buffer.toString(chunk)
@@ -89,6 +92,7 @@ module Module: Module = {
 
     // on `close` from `stdin` or `process`
     let promiseOnClose = Promise.make((resolve, _) => {
+      Js.log("[ LOG ][ " ++ path ++ "] Process.onClose: Waiting for process to close")
       process
       ->NodeJs.ChildProcess.stdin
       ->Option.forEach(stream =>
@@ -104,21 +108,26 @@ module Module: Module = {
 
     // on errors and anomalies
     let promiseOnExit = Promise.make((resolve, _) => {
+      Js.log("[ LOG ][ " ++ path ++ "] Process.onExit: Waiting for process to exit")
       process
       ->NodeJs.ChildProcess.onExit(code => resolve(code))
       ->ignore
     })
 
     process
-    ->NodeJs.ChildProcess.onDisconnect(() => chan->Chan.emit(Event(OnDestroyed)))
-    ->NodeJs.ChildProcess.onError(exn =>
+    ->NodeJs.ChildProcess.onDisconnect(() => {
+      Js.log("[ LOG ][ " ++ path ++ "] Process.onDisconnect: Process disconnected")
+      chan->Chan.emit(Event(OnDestroyed))})
+    ->NodeJs.ChildProcess.onError(exn =>{
+      Js.log("[ LOG ][ " ++ path ++ "] Process.onError: Process error: " ++ Util.JsError.toString(exn))
       chan->Chan.emit(Event(OnError(Util.JsError.toString(exn))))
-    )
+    })
     ->ignore
 
     // emit `OnExit` when either `close` or `exit` was received
     Promise.race([promiseOnExit, promiseOnClose])
     ->Promise.thenResolve(exitCode => {
+      Js.log("[ LOG ][ " ++ path ++ "] Process.onExit: Process exited with code " ++ string_of_int(exitCode))
       chan->Chan.emit(Event(OnExit(exitCode)))
     })
     ->ignore
@@ -155,6 +164,7 @@ module Module: Module = {
   let send = (self, request): bool => {
     switch self.status {
     | Created(process) =>
+      Js.log("[ LOG ] Process.send: Sending request: " ++ request)
       let payload = NodeJs.Buffer.fromString(request ++ NodeJs.Os.eol)
       process
       ->NodeJs.ChildProcess.stdin
@@ -164,7 +174,9 @@ module Module: Module = {
         ->ignore
       )
       true
-    | _ => false
+    | _ => 
+      Js.log("[ LOG ] Process.send: Cannot send, process is not in a valid state")
+      false
     }
   }