Store names in special forms to facilitate debugging.

Author: objecthub

Sources/LispKit/Compiler/EvalError.swift

@@ -85,7 +85,7 @@ public enum EvalError: Int, Hashable {
   public var message: String {
     switch self {
       case .illegalKeywordUsage:
-        return "syntactic keywords may not be used as expressions: $0"
+        return "illegal usage of syntactic keyword as expression: $0"
       case .illegalFormalParameter:
         return "illegal formal parameter: $0"
       case .illegalFormalRestParameter:

Sources/LispKit/Data/Environment.swift

@@ -110,7 +110,9 @@ public final class Environment: Reference, CustomStringConvertible {
     self.bindings = [:]
     super.init()
     self.box = WeakBox(self)
-    self.define(context.symbols.`import`, as: .special(SpecialForm(Environment.compileImport)))
+    self.define(context.symbols.`import`,
+                as: .special(SpecialForm(context.symbols.`import`.description,
+                                         Environment.compileImport)))
   }
 
   /// Initializes an empty environment for executing a program read from `filename`.

Sources/LispKit/Data/Expr.swift

@@ -818,7 +818,7 @@ extension Expr: CustomStringConvertible {
               return "#<procedure \(proc.name)>"
           }
         case .special(let special):
-          return "#<special \(special.identityString)>"
+          return "#<special \(special.name)>"
         case .env(let environment):
           var type: String = ""
           switch environment.kind {

Sources/LispKit/Data/Procedure.swift

@@ -261,7 +261,7 @@ public final class Procedure: Reference, CustomStringConvertible {
     }
   }
 
-  /// Returns the original name of this procedure if it exists and is known. This method either
+  /// Returns the original name of this procedure if it exists and is known.
   public var originalName: String? {
     switch self.kind {
       case .primitive(let str, _, _):

Sources/LispKit/Data/SpecialForm.swift

@@ -35,14 +35,20 @@ public final class SpecialForm: Reference, CustomStringConvertible {
   /// Special form kind
   internal let kind: Kind
 
+  /// Original name of the special form, if available; this is the name of the special
+  /// form at definition time.
+  public let originalName: String?
+  
   /// Initializer for primitive special forms
-  public init(_ compiler: @escaping FormCompiler) {
+  public init(_ name: String?, _ compiler: @escaping FormCompiler) {
     self.kind = .primitive(compiler)
+    self.originalName = name
   }
 
   /// Initializer for special forms based on macro transformers
-  public init(_ transformer: Procedure) {
+  public init(_ name: String?, _ transformer: Procedure) {
     self.kind = .macro(transformer)
+    self.originalName = name
   }
 
   public func mark(_ tag: UInt8) {
@@ -54,8 +60,23 @@ public final class SpecialForm: Reference, CustomStringConvertible {
     }
   }
 
+  /// Returns the name of this special form. This method either returns the name of a primitive
+  /// special form or a macro transformer. If the name isn't available, the identity is returned
+  /// as a hex string.
+  public var name: String {
+    guard let originalName = self.originalName else {
+      return self.identityString
+    }
+    switch self.kind {
+      case .primitive(_):
+        return originalName
+      case .macro(_):
+        return "\(originalName)@\(self.identityString)"
+    }
+  }
+  
   /// A textual description
   public var description: String {
-    return "special:\(self.identityString)"
+    return "special:" + self.name
   }
 }

Sources/LispKit/Primitives/BaseLibrary.swift

@@ -41,32 +41,32 @@ public final class BaseLibrary: NativeLibrary {
     self.define(Procedure("equal?", isEqual, compileEqual))
     self.define(Procedure("eqv?", isEqv, compileEqv))
     self.define(Procedure("eq?", isEq, compileEq))
-    self.define("quote", as: SpecialForm(compileQuote))
-    self.define("quasiquote", as: SpecialForm(compileQuasiquote))
-    self.define("lambda", as: SpecialForm(compileLambda))
-    self.define("case-lambda", as: SpecialForm(compileCaseLambda))
+    self.define(SpecialForm("quote", compileQuote))
+    self.define(SpecialForm("quasiquote", compileQuasiquote))
+    self.define(SpecialForm("lambda", compileLambda))
+    self.define(SpecialForm("case-lambda", compileCaseLambda))
 
     // Definition primitives
-    self.define("define", as: SpecialForm(compileDefine))
-    self.define("define-values", as: SpecialForm(compileDefineValues))
-    self.define("define-syntax", as: SpecialForm(compileDefineSyntax))
-    self.define("define-library", as: SpecialForm(compileDefineLibrary))
-    self.define("syntax-rules", as: SpecialForm(compileSyntaxRules))
-    self.define("set!", as: SpecialForm(compileSet))
+    self.define(SpecialForm("define", compileDefine))
+    self.define(SpecialForm("define-values", compileDefineValues))
+    self.define(SpecialForm("define-syntax", compileDefineSyntax))
+    self.define(SpecialForm("define-library", compileDefineLibrary))
+    self.define(SpecialForm("syntax-rules", compileSyntaxRules))
+    self.define(SpecialForm("set!", compileSet))
 
     // Delayed execution
     self.define(Procedure("promise?", isPromise))
     self.define(Procedure("make-promise", makePromise))
     self.define(Procedure("eager", makePromise))
-    self.define("delay", as: SpecialForm(compileDelay))
-    self.define("delay-force", as: SpecialForm(compileDelayForce))
-    self.define("lazy", as: SpecialForm(compileDelayForce))
+    self.define(SpecialForm("delay", compileDelay))
+    self.define(SpecialForm("delay-force", compileDelayForce))
+    self.define(SpecialForm("lazy", compileDelayForce))
     self.define(Procedure("stream?", isStream))
     self.define(Procedure("make-stream", makeStream))
     self.define(Procedure("stream-eager", makeStream))
-    self.define("stream-delay", as: SpecialForm(compileStreamDelay))
-    self.define("stream-delay-force", as: SpecialForm(compileStreamDelayForce))
-    self.define("stream-lazy", as: SpecialForm(compileStreamDelayForce))
+    self.define(SpecialForm("stream-delay", compileStreamDelay))
+    self.define(SpecialForm("stream-delay-force", compileStreamDelayForce))
+    self.define(SpecialForm("stream-lazy", compileStreamDelayForce))
     self.define(Procedure("force", compileForce, in: self.context))
 
     // Symbol primitives
@@ -79,14 +79,14 @@ public final class BaseLibrary: NativeLibrary {
     // Boolean primitives
     self.define(Procedure("boolean?", isBoolean))
     self.define(Procedure("boolean=?", isBooleanEq))
-    self.define("and", as: SpecialForm(compileAnd))
-    self.define("or", as: SpecialForm(compileOr))
+    self.define(SpecialForm("and", compileAnd))
+    self.define(SpecialForm("or", compileOr))
     self.define(Procedure("not", not, compileNot))
 
     // Conditional & inclusion compilation
-    self.define("cond-expand", as: SpecialForm(compileCondExpand))
-    self.define("include", as: SpecialForm(include))
-    self.define("include-ci", as: SpecialForm(includeCi))
+    self.define(SpecialForm("cond-expand", compileCondExpand))
+    self.define(SpecialForm("include", include))
+    self.define(SpecialForm("include-ci", includeCi))
 
     // Multiple values
     self.define(Procedure("values", values, compileValues))
@@ -102,7 +102,7 @@ public final class BaseLibrary: NativeLibrary {
     self.define(Procedure("interaction-environment", interactionEnvironment))
 
     // Syntax errors
-    self.define("syntax-error", as: SpecialForm(compileSyntaxError))
+    self.define(SpecialForm("syntax-error", compileSyntaxError))
 
     // Helpers
     self.define(Procedure("void", BaseLibrary.voidConst))

Sources/LispKit/Primitives/ControlFlowLibrary.swift

@@ -28,23 +28,23 @@ public final class ControlFlowLibrary: NativeLibrary {
 
   /// Declarations of the library.
   public override func declarations() {
-    self.define("begin", as: SpecialForm(self.compileBegin))
-    self.define("let", as: SpecialForm(self.compileLet))
-    self.define("let*", as: SpecialForm(self.compileLetStar))
-    self.define("letrec", as: SpecialForm(self.compileLetRec))
-    self.define("letrec*", as: SpecialForm(self.compileLetRecStar))
-    self.define("let-values", as: SpecialForm(self.compileLetValues))
-    self.define("let*-values", as: SpecialForm(self.compileLetStarValues))
-    self.define("let-optionals", as: SpecialForm(self.compileLetOptionals))
-    self.define("let*-optionals", as: SpecialForm(self.compileLetStarOptionals))
-    self.define("let-syntax", as: SpecialForm(self.compileLetSyntax))
-    self.define("letrec-syntax", as: SpecialForm(self.compileLetRecSyntax))
-    self.define("do", as: SpecialForm(self.compileDo))
-    self.define("if", as: SpecialForm(self.compileIf))
-    self.define("when", as: SpecialForm(self.compileWhen))
-    self.define("unless", as: SpecialForm(self.compileUnless))
-    self.define("cond", as: SpecialForm(self.compileCond))
-    self.define("case", as: SpecialForm(self.compileCase))
+    self.define(SpecialForm("begin", self.compileBegin))
+    self.define(SpecialForm("let", self.compileLet))
+    self.define(SpecialForm("let*", self.compileLetStar))
+    self.define(SpecialForm("letrec", self.compileLetRec))
+    self.define(SpecialForm("letrec*", self.compileLetRecStar))
+    self.define(SpecialForm("let-values", self.compileLetValues))
+    self.define(SpecialForm("let*-values", self.compileLetStarValues))
+    self.define(SpecialForm("let-optionals", self.compileLetOptionals))
+    self.define(SpecialForm("let*-optionals", self.compileLetStarOptionals))
+    self.define(SpecialForm("let-syntax", self.compileLetSyntax))
+    self.define(SpecialForm("letrec-syntax", self.compileLetRecSyntax))
+    self.define(SpecialForm("do", self.compileDo))
+    self.define(SpecialForm("if", self.compileIf))
+    self.define(SpecialForm("when", self.compileWhen))
+    self.define(SpecialForm("unless", self.compileUnless))
+    self.define(SpecialForm("cond", self.compileCond))
+    self.define(SpecialForm("case", self.compileCase))
   }
 
   private func splitBindings(_ bindingList: Expr) throws -> (Expr, Expr) {

Sources/LispKit/Primitives/SystemLibrary.swift

@@ -86,7 +86,7 @@ public final class SystemLibrary: NativeLibrary {
     self.define(Procedure("loaded-libraries", self.loadedLibraries))
     self.define(Procedure("loaded-sources", self.loadedSources))
     self.define(Procedure("environment-info", self.environmentInfo))
-    self.define("time", as: SpecialForm(self.compileTime))
+    self.define(SpecialForm("time", self.compileTime))
     self.define(Procedure("seconds-from-gmt", self.secondsFromGmt))
     self.define(Procedure("current-second", self.currentSecond))
     self.define(Procedure("current-jiffy", self.currentJiffy))

Sources/LispKit/Runtime/NativeLibrary.swift

@@ -178,6 +178,12 @@ open class NativeLibrary: Library {
     return self.define(proc.name, as: .procedure(proc), export: export)
   }
 
+  /// Declares a new special form using the internal name of `spec`.
+  /// The optional parameter `export` determines whether the definition is exported or internal.
+  @discardableResult public func define(_ spec: SpecialForm, export: Bool = true) -> Int {
+    return self.define(spec.name, as: .special(spec), export: export)
+  }
+  
   /// Declares a new definition for the given procedure `proc` and name `name`. The optional
   /// parameter `export` determines whether the definition is exported or internal.
   @discardableResult public func define(_ name: String,

Sources/LispKit/Runtime/VirtualMachine.swift

@@ -1018,7 +1018,7 @@ public final class VirtualMachine: TrackedObject {
             case .uninit(let sym):
               throw RuntimeError.eval(.variableNotYetInitialized, .symbol(sym))
             case .special(_):
-              throw RuntimeError.eval(.illegalKeywordUsage, .undef) // TODO: can this really happen?
+              throw RuntimeError.eval(.illegalKeywordUsage, value)
             default:
               self.push(value)
           }
@@ -1194,7 +1194,7 @@ public final class VirtualMachine: TrackedObject {
           guard case .procedure(let proc) = transformer else {
             throw RuntimeError.eval(.malformedTransformer, transformer)
           }
-          self.push(.special(SpecialForm(proc)))
+          self.push(.special(SpecialForm(nil, proc)))
         case .compile:
           let environment = try self.pop().asEnvironment()
           let code = try Compiler.compile(expr: .makeList(self.pop()),