compiler, runtime: Support Formatted Error Messages

Make it possible to output formatted error messages using a
flexible API that includes an ability to specify styles and
formatters.

Signed-off-by: Will Hawkins <hawkinsw@obs.cr>

Sources/Common/Error.swift

@@ -16,8 +16,8 @@
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
 public struct Error: Errorable, Equatable, CustomStringConvertible {
-  public func format() -> String {
-    return self.description
+  public func format(_ formatter: any Formattable) -> String {
+    return self._msg
   }
 
   public func msg() -> String {
@@ -40,11 +40,10 @@ public struct Error: Errorable, Equatable, CustomStringConvertible {
 }
 
 public struct ErrorWithLocation: Errorable, Equatable, CustomStringConvertible {
-  let startFormat: String = "\u{1B}[31;1;4m"
-  let endFormat: String = "\u{1B}[0m"
-
-  public func format() -> String {
-    return startFormat + "\(self.location)" + endFormat + ": \(self._msg)"
+  public func format(_ formatter: any Formattable) -> String {
+    let bold_red = Style(StyleColor.Red, [StyleFormat.Bold])
+    let formatted_location = formatter.formatWithStyle(self.location.description, bold_red)
+    return formatted_location + ": " + self._msg
   }
 
   public func msg() -> String {
@@ -70,8 +69,10 @@ public struct ErrorWithLocation: Errorable, Equatable, CustomStringConvertible {
 }
 
 public struct Errors: Errorable, CustomStringConvertible {
-  public func format() -> String {
-    return self.description
+  public func format(_ formatter: any Formattable) -> String {
+    self.errors.map() { error in
+      error.format(formatter)
+    }.joined(separator: "\n")
   }
 
   public func msg() -> String {
@@ -103,6 +104,12 @@ public struct ErrorWithLabel: Errorable {
   let label: String
   let error: any Errorable
 
+  public func format(_ formatter: any Formattable) -> String {
+    let green = Style(StyleColor.Green)
+    let formatted_label = formatter.formatWithStyle(self.label, green)
+    return formatted_label + self.error.format(formatter)
+  }
+
   public init(_ label: String, _ error: any Errorable) {
     self.label = label
     self.error = error

Sources/Common/Formatter.swift

@@ -0,0 +1,116 @@
+// p4rse, Copyright 2026, Will Hawkins
+//
+// This file is part of p4rse.
+//
+// This file is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+public enum StyleColor {
+  case Red
+  case Blue
+  case Green
+}
+
+public enum StyleFormat {
+  case Underline
+  case Bold
+}
+
+public struct Style: Equatable {
+  let color: StyleColor?
+  let format: [StyleFormat]
+
+  public init(_ color: StyleColor?, _ format: [StyleFormat] = []) {
+    self.color = color
+    self.format = format
+  }
+
+  public func update(setColor color: StyleColor) -> Style {
+    return Style(color, self.format)
+  }
+
+  public func removeColor() -> Style {
+    return Style(nil, self.format)
+  }
+
+  public func update(addFormat format: StyleFormat) -> Style {
+    return if self.format.contains(format) {
+      Style(self.color, self.format)
+    } else {
+      Style(self.color, self.format + [format])
+    }
+  }
+
+  public func update(removeFormat format: StyleFormat) -> Style {
+    let new_format = self.format.filter { existing_format in
+      existing_format != format
+    }
+    return Style(self.color, new_format)
+  }
+
+  public func getColor() -> StyleColor? {
+    return self.color
+  }
+
+  public func getFormat() -> [StyleFormat] {
+    return self.format
+  }
+}
+
+public struct FormatterPlain: Formattable {
+  public init() {}
+  public func formatWithStyle(_ value: String, _ style: Style) -> String {
+    return value
+  }
+
+}
+
+public struct FormatterAnsi: Formattable {
+
+  public init() {}
+
+  let startFormat: String = "\u{1B}["
+  let resetFormat: String = "\u{1B}[0m"
+
+  let colorMap = [
+    StyleColor.Red: "31",
+    StyleColor.Green: "32",
+    StyleColor.Blue: "34",
+  ]
+
+  let styleMap = [
+    StyleFormat.Underline: "4",
+    StyleFormat.Bold: "1",
+  ]
+
+  public func formatWithStyle(_ value: String, _ style: Style) -> String {
+    let color =
+      if let color = style.getColor() {
+        self.colorMap[color]!
+      } else {
+        ""
+      }
+
+    let style = style.getFormat().map { format in
+      String(self.styleMap[format]!)
+    }.joined(separator: ";")
+
+    if color.isEmpty && style.isEmpty {
+      return value
+    }
+
+    let code = startFormat + color + ((!color.isEmpty && !style.isEmpty) ? ";" : "") + style + "m"
+
+    return code + value + resetFormat
+  }
+}

Sources/Common/Protocols.swift

@@ -71,7 +71,7 @@ public protocol ProgramExecutionEvaluator {
 }
 
 public protocol Errorable: CustomStringConvertible {
-  func format() -> String
+  func format(_ formatter: Formattable) -> String
   func msg() -> String
   func append(error: any Errorable) -> any Errorable
   func eq(_ rhs: any Errorable) -> Bool
@@ -83,6 +83,10 @@ extension Errorable {
   }
 }
 
+public protocol Formattable {
+  func formatWithStyle(_ value: String, _ style: Style) -> String
+}
+
 extension ProgramExecutionEvaluator {
   public func ExecuteStatements(
     _ statements: [EvaluatableStatement], inExecution execution: ProgramExecution

Sources/Common/Result.swift

@@ -62,7 +62,7 @@ extension Result: CustomStringConvertible where OKT: CustomStringConvertible {
   public var description: String {
     switch self {
     case Result.Error(let e):
-      return e.format()
+      return e.msg()
     case Result.Ok(let o):
       return "Ok: \(o)"
     }