[WIP] IDE Support

doc/reference/std/getopt.md

@@ -4,7 +4,7 @@ This is the old name of the [`:std/cli/getopt`](cli/getopt.md) module,
 that provides facilities for command line argument parsing.
 
 Up to Gerbil v0.18, `:std/getopt` was the only name for this module.
-As of Gerbil v0.19, both names are supported.
+Up to and including Gerbil v0.19, both names are supported.
 However, we recommend you use the new name `:std/cli/getopt` from now on,
 as we may remove the old name at some point in the future.
 

doc/reference/std/instance.md

@@ -3,14 +3,11 @@
 When defining many methods on a class, possibly with an interface wrapper, a short form is nice to reduce bloat.
 
 ::: tip To use the bindings from this module:
-
 ```scheme
 (import :std/instance)
 ```
-
 :::
 
-
 ## Introduction
 
 Gerbil has a strong type system which is close a "Meta-language"(`ML`)! That is to say: a functional programming language with a polymorphic Hindley–Milner type system.

src/gerbil/builtin.ssxi.ss

@@ -963,7 +963,7 @@ package: gerbil
  (input-port-characters-buffered (port::t) integer::t effect: (io))
  (input-port-column (port::t) integer::t effect: (io))
  (input-port-line (port::t) integer::t effect: (io))
- (input-port-readtable (port::t) integer::t effect: (io))
+ (input-port-readtable (port::t) readtable::t effect: (io))
  (input-port-readtable-set! (port::t readtable::t) void::t effect: (mut io))
  (input-port-timeout-set! [((port::t t::t) void::t effect: (mut io))
                            ((port::t t::t procedure::t) void::t effect: (mut io))])

src/gerbil/main.ss

@@ -66,6 +66,7 @@ package: gerbil
     ("clean"       "gxpkg" "clean")
     ("env"         "gxpkg" "env")
     ("pkg"         "gxpkg")
+    ("swank"       "gxswank")
     ("test"        "gxtest")
     ("tags"        "gxtags")
     ("prof"        "gxprof")
@@ -81,6 +82,7 @@ package: gerbil
     ("clean"       "gxpkg" "help" "clean")
     ("env"         "gxpkg" "help" "env")
     ("pkg"         "gxpkg" "help")
+    ("swank"       "gxswank" "-h")
     ("test"        "gxtest" "-h")
     ("tags"        "gxtags" "-h")
     ("prof"        "gxprof" "-h")
@@ -107,6 +109,7 @@ package: gerbil
   (displayln "  clean                            clean build artifactacts for a package (gxpkg clean)")
   (displayln "  env                              eval a shell command in the local package environment (gxpkg env)")
   (displayln "  pkg                              invoke the gerbil package manager (gxpkg)")
+  (displayln "  swank                            run a swank server (gxswank)")
   (displayln "  test                             run tests (gxtest)")
   (displayln "  tags                             create emacs tags (gxtags)")
   (displayln "  prof                             profile a dynamic executable module (gxprof)")

src/std/build-spec.ss

@@ -168,6 +168,28 @@
     "srfi/160/c64"
     "srfi/160/c128"
     "srfi/212"
+    "ide/model"
+    "ide/interface"
+    "ide/swank/api"
+    "ide/swank/message"
+    "ide/swank/context"
+    "ide/swank/autodoc"
+    "ide/swank/repl"
+    "ide/swank/presentation"
+    "ide/swank/top"
+    "ide/swank/eval"
+    "ide/swank/completions"
+    "ide/swank/handlers"
+    "ide/swank/server"
+    "ide/swank"
+    ;; :std/monad
+    "monad/interface"
+    "monad/syntax"
+    "monad/identity"
+    "monad/list"
+    "monad/state"
+    "monad/error"
+    "monad"
     ;; :std/mime
     "mime/struct"
     (gxc: "mime/types" (extra-inputs: ("mime/mime.types")))

src/std/ide/interface.ss

@@ -0,0 +1,49 @@
+;;; -*- Gerbil -*-
+;;; © vyzo
+;;; IDE interface
+;;(import ./model)
+(export #t)
+(import ./model)
+
+(interface IDEServer
+  ;; updates the workspace tracked files
+  ;; added, modified, and removed are lists of file paths.
+  (update-workspace (added : :list) (modified : :list) (removed : :list))
+
+  ;; resolve a symbol in source to an entity
+  (resolve (src : Source)) => Entity
+
+  ;; finds references of a specific entity within a scope
+  ;; - e is the entity for which references should be searched
+  ;; - scope can be:
+  ;;   - #f, in which case the entire workspace is searched
+  ;;   - a file path for searching a specific file/module
+  ;;   - a list of file paths for searching specific file/modules
+  ;; returns a list of References
+  (find-refs (e : Entity) (scope :~ reference-scope? := #f)) => :list
+
+  ;; finds documentation for an entity
+  ;; returns a list of Location with relevant documentation
+  (find-docs (e : Entity)) => :list
+
+  ;; complete the last symbol in a partial s-expr in some source span
+  ;; returns a list of Completions
+  (complete (src : Source)) => :list
+
+  ;; evals an sexpr in some source span
+  (eval (src : Source)) => Result
+
+  ;; expands an sexpr in some source span
+  (expand (src : Source) (fully? : :boolean := #f)) => Result
+
+  ;; visits a file/module
+  ;; Returns a parsed representation (SExpr) of the file/module's code
+  (visit-file (path : :string)) => Result
+
+  ;; updates the in-memory reprsentation of a file/module
+  (edit-file (replace-at : SourceFileSpan) (data : :string) (span : Span) ))
+
+(def (reference-scope? o)
+  (or (not o)
+      (string? o)
+      (and (list? o) (andmap string? o))))

src/std/ide/model.ss

@@ -0,0 +1,124 @@
+;;; -*- Gerbil -*-
+;;; © vyzo
+;;; IDE model types
+(import :std/actor-v18/message)
+(export #t)
+
+;; base class for serializable objects; actor io
+(defclass (Serializable message) ())
+
+;; source locations and anchors
+(defclass (Source Serializable) ())
+(defclass (SourceString Source) ((value : :string)))
+(defclass (File Serializable) ((path : :string)))
+(defclass (Pos Serializable) ((line : :fixnum) (col : :fixnum)))
+(defclass (Span Serializable) ((start : Pos) (end : Pos)))
+
+(defclass (SourceFilePos Source File Pos) ())
+(defclass (SourceFileSpan Source File Span) ())
+(defclass (SourceFileString SourceString File) ())
+(defclass (ModuleRef Serializable) ((module : :symbol)))
+(defclass (SourceModuleString SourceString ModuleRef) ())
+(defclass (SourceFileModuleString SourceModuleString File) ())
+
+;; uniquely identifiable entities
+(defclass (Entity Serializable)
+  ((id   : :symbol)                   ; the entity identifier
+   (name : :symbol)                   ; the human "name" of the entity
+   (ctx  : :t)))     ; the context of the identifier
+
+;; base class for entity types
+(defclass (Type Entity) ())
+
+;; identifiers
+(defclass (Identifier Entity)
+  ((type  :? Type)))
+
+;; identifier types
+(defclass (MetaObject Type) ())
+(defclass (Class MetaObject) ())
+(defclass (Interface MetaObject) ())
+
+(defclass (Object Type) ())
+(defclass (StandardObject Object) ())
+(defclass (ClassInstance StandardObject) ())
+(defclass (InterfaceInstance StandardObject) ())
+(defclass (SystemObject Object) ())
+(defclass (Procedure SystemObject) ())
+
+(defclass (MetaSyntacticObject Type) ())
+(defclass (Macro MetaSyntacticObject) ())
+(defclass (Module MetaSyntacticObject) ())
+
+;; completions
+(defclass (Completion Serializable)
+  ((symbol : :symbol)   ; the completion symbol
+   (entity : Entity)))  ; the completion entity
+
+;; objects with a location
+(defclass (Location Serializable) ((loc : SourceFileSpan)))
+
+;; entity source references
+(defclass (Reference Location)
+  ((e : Entity)))    ; the entity referred
+
+;; evaluation and expansion results
+(defclass (Result Serializable) ())
+
+;; S-Expressions
+(defclass (SExpr Result)
+  ((hd : :symbol)
+   (e  : :list)))
+
+;; literal values
+(defclass (Literal Result)
+  ((value : :string)))
+
+;; errors
+(defclass (Error Result)
+  ((msg : :string)))
+
+;; register message classes for actor io
+(defsyntax (declare-serializable stx)
+  (syntax-case stx ()
+    ((_ id ...)
+     (with-syntax (((id::t ...)
+                    (stx-map (lambda (id) (stx-identifier id id "::t")) #'(id ...))))
+       #'(begin
+           (register-message-type! id::t)
+           ...)))))
+
+(declare-serializable
+ Serializable
+ Source
+ SourceString
+ File
+ Pos
+ Span
+ SourceFilePos
+ SourceFileSpan
+ SourceFileString
+ ModuleRef
+ SourceModuleString
+ SourceFileModuleString
+ Entity
+ Type
+ Identifier
+ MetaObject
+ Class
+ Interface
+ StandardObject
+ ClassInstance
+ InterfaceInstance
+ SystemObject
+ Procedure
+ MetaSyntacticObject
+ Macro
+ Module
+ Completion
+ Location
+ Reference
+ Result
+ Literal
+ SExpr
+ Error)

src/std/ide/swank.ss

@@ -0,0 +1,23 @@
+(import
+  ./swank/api
+  ./swank/message
+  ./swank/context
+  ./swank/presentation
+  ./swank/eval
+  ./swank/top
+  ./swank/completions
+  ./swank/autodoc
+  ./swank/handlers
+  ./swank/server)
+(export
+  (import:
+   ./swank/api
+   ./swank/message
+   ./swank/context
+   ./swank/presentation
+   ./swank/eval
+   ./swank/top
+   ./swank/completions
+   ./swank/autodoc
+   ./swank/handlers
+   ./swank/server))

src/std/ide/swank/README.org

@@ -0,0 +1,104 @@
+#+TITLE: Swank, a SLIME backend for an IDE
+
+* SLIME and Swank: Graphical REPL
+
+SLIME, the Superior Lisp Interaction Mode for Emacs, is an Emacs mode
+for developing Lisp applications.
+-- https://en.wikipedia.org/wiki/SLIME
+
+SLIME uses a backend called Swank that is loaded into Lisp to turn
+Emacs into a featured REPL along with an IDE for lisp use.
+
+* Minimal Emacs setup
+
+There are some developers that (**gasp**) don't use Emacs as their
+primary go to application. Having said that even without using the
+editor portion the REPL itself is useful and continues to grow into a
+wonderful interface to Gerbil.
+
+If you already use emacs it may be as simple as adding the following
+to your init file.
+
+#+begin_src emacs-lisp
+  (use-package slime
+    :hook ((gerbil-mode . slime-mode)))
+
+  (defun gerbil-slime-init-function (file encoding)
+    (format "(begin (import (prefix-in :std/ide/swank swank#))
+    (let ((port (+ 10000 (random-integer 55535))))
+      (swank#create-server port: port)
+      (with-output-to-file %S (cut write port))))\n\n"
+  	 file))
+
+  (cl-defun gerbil-slime-start
+      (&key (program "/opt/gerbil/current/bin/gerbil") program-args
+  	  directory
+  	  (coding-system slime-net-coding-system)
+  	  (init 'gerbil-slime-init-function)
+  	  (name 'gerbil)
+  	  (buffer "*inferior-gerbil*")
+  	  init-function
+  	  env)
+    "Start a Gerbil process and connect to it.
+  This function is intended for programmatic use if `gerbil-slime' is not
+  flexible enough.
+
+  PROGRAM and PROGRAM-ARGS are the filename and argument strings
+    for the subprocess.
+  INIT is a function that should return a string to load and start
+    Swank. The function will be called with the PORT-FILENAME and ENCODING as
+    arguments.  INIT defaults to `gerbil-slime-init-command'.
+  CODING-SYSTEM a symbol for the coding system. The default is
+    slime-net-coding-system
+  ENV environment variables for the subprocess (see `process-environment').
+  INIT-FUNCTION function to call right after the connection is established.
+  BUFFER the name of the buffer to use for the subprocess.
+  NAME a symbol to describe the Lisp implementation
+  DIRECTORY change to this directory before starting the process.
+  "
+    (let ((args (list :program program :program-args program-args :buffer buffer
+                      :coding-system coding-system :init init :name name
+                      :init-function init-function :env env)))
+      (slime-check-coding-system coding-system)
+      (when (slime-bytecode-stale-p)
+        (slime-urge-bytecode-recompile))
+      (let ((proc (slime-maybe-start-lisp program program-args env
+                                          directory buffer)))
+        (slime-inferior-connect proc args)
+        (pop-to-buffer (process-buffer proc)))))
+
+  (defun gerbil-slime (&optional command coding-system)
+    "Start an inferior^_superior Lisp and connect to its Swank server."
+    (interactive)
+    (slime-setup)
+    (gerbil-slime-start))
+
+
+
+#+end_src
+
+Or you could [[https://slime.common-lisp.dev/doc/html/Getting-started.html#Getting-started][download it]] and put it in your =load-path=.
+
+* Running the Swank Server in Gerbil
+
+#+begin_src sh
+gerbil swank --help
+gxswank: The Gerbil HTTP Daemon
+
+Usage: gxwank [option ...]
+
+Options:
+ -g --global-env                  use the user global env even in local package context
+ -a --address <host>              The IP or hostname to listen on [default: localhost]
+ -p --port <port>                 The port number on which the Swank server listens for connections [default: 4005]
+ -d --dont-close <dont-close>     Close the acceptor on client disconnect if anything but true [default: true]
+ -h --help                        display help
+
+#+end_src
+
+
+
+
+
+
+