Merge branch 'develop'

Author: helje5

.editorconfig

@@ -0,0 +1,8 @@
+[*]
+indent_style = space
+indent_size = 2
+tab_width = 8
+max_line_length = 80
+trim_trailing_whitespace = false
+end_of_line = lf
+insert_final_newline = true

Plugins/Libraries/LighterCodeGenAST/Generation/GenExtensions.swift

@@ -1,6 +1,6 @@
 //
 //  Created by Helge Heß.
-//  Copyright © 2022 ZeeZide GmbH.
+//  Copyright © 2022-2024 ZeeZide GmbH.
 //
 
 public extension CodeGenerator {
@@ -23,10 +23,16 @@ public extension CodeGenerator {
     }
 
     appendIndent()
-    if value.public { append("public ") }
+    if value.public && value.conformances.isEmpty { append("public ") }
     append("extension ")
     append(string(for: value.extendedType))
 
+    if !value.conformances.isEmpty {
+      append(configuration.typeConformanceSeparator) // " : "
+      append(value.conformances.map(string(for:))
+        .joined(separator: configuration.identifierListSeparator))
+    }
+
     if !value.genericConstraints.isEmpty {
       let constraints = value.genericConstraints.map({ string(for: $0) })
         .joined(separator: configuration.identifierListSeparator)
@@ -42,9 +48,17 @@ public extension CodeGenerator {
     }
 
     indent {
-      for structure in value.structures {
+      for typeDefinition in value.typeDefinitions {
         writeln()
-        generateStruct(structure, omitPublic: value.public)
+        generateTypeDefinition(typeDefinition, omitPublic: value.public)
+      }
+      
+      var lastHadComment = false
+      if !value.typeVariables.isEmpty { writeln() }
+      for variable in value.typeVariables {
+        if lastHadComment { writeln() }
+        generateInstanceVariable(variable, static: true)
+        lastHadComment = variable.comment != nil
       }
 
       for function in value.typeFunctions {

Plugins/Libraries/LighterCodeGenAST/Generation/GenFunctions.swift

@@ -135,6 +135,7 @@ public extension CodeGenerator {
            + ">"
     }()
     var preamble = ""
+    if value.override              { preamble.append("override ") }
     if value.public && !omitPublic { preamble.append("public ")   }
     if `static`                    { preamble.append("static ")   }
     if value.mutating              { preamble.append("mutating ") }
@@ -271,38 +272,55 @@ public extension CodeGenerator {
     append(string(for: value.type))
 
     let allowSingleReturn = true // make an option?
-    if allowSingleReturn && value.statements.count == 1,
-       value.setStatements.isEmpty,
-       let statement = value.statements.first,
-       case .return(let expression) = statement
-    {
-      append(" { ")
-      appendExpression(expression)
-      append(" }")
-      appendEOL()
-    }
-    else {
-      if value.setStatements.isEmpty {
-        indentedCodeBlock {
-          generateStatements(value.statements, allowSingleReturn: true)
+    
+    func genStatements(_ statements: [ Statement ]) {
+      if allowSingleReturn && statements.count == 1,
+         let statement = statements.first,
+         case .return(let expression) = statement
+      {
+        append(" { ")
+        appendExpression(expression)
+        append(" }")
+        appendEOL()
+      }
+      else if statements.count == 1,
+              let statement = statements.first,
+              case .variableAssignment(let instance, let name, let value)
+                = statement
+      {
+        append(" { ")
+        if let instance = instance {
+          append(instance) // "self" can be used here
+          append(".")
         }
+        append(tickedWhenReserved(name))
+        append(configuration.propertyValueSeparator) // " = "
+        appendExpression(value)
+        append(" }")
+        appendEOL()
       }
       else {
         indentedCodeBlock {
-          appendIndent()
-          append("set")
-          indentedCodeBlock {
-            generateStatements(value.setStatements, allowSingleReturn: true)
-          }
-          appendIndent()
-          append("get")
-          indentedCodeBlock {
-            generateStatements(value.statements, allowSingleReturn: true)
-          }
+          generateStatements(statements, allowSingleReturn: allowSingleReturn)
         }
       }
     }
 
+    if value.setStatements.isEmpty {
+      genStatements(value.statements)
+    }
+    else {
+      indentedCodeBlock {
+        appendIndent()
+        append("set")
+        genStatements(value.setStatements)
+        
+        appendIndent()
+        append("get")
+        genStatements(value.statements)
+      }
+    }
+    
     if let ( major, minor ) = value.minimumSwiftVersion {
       assert(major >= 5)
       writeln("#endif // swift(>=\(major).\(minor))")

Plugins/Libraries/LighterCodeGenAST/Generation/GenStatements.swift

@@ -57,7 +57,12 @@ public extension CodeGenerator {
         append("return ")
         appendExpression(expression)
         appendEOLIfMissing()
-      
+      case .`throw`(let expression):
+        appendIndent()
+        append("throw ")
+        appendExpression(expression)
+        appendEOLIfMissing()
+
       case .forInRange(let counter, let from, let to, let stmts):
         appendIndent()
         append("for \(counter) in \(string(for: from))..<\(string(for: to))")
@@ -72,6 +77,46 @@ public extension CodeGenerator {
         }
       case .break: writeln("break")
 
+      case .`switch`(let expression, let pairs, let def):
+        assert(!pairs.isEmpty)
+        
+        func generateCaseStatements(_ statements: [ Statement ]) {
+          if statements.count == 1, let stmt = statements.first {
+            switch stmt {
+              case .return(let expression):
+                append(" return ")
+                appendExpression(expression)
+                appendEOLIfMissing()
+                return
+              case .throw(let expression):
+                append(" throw ")
+                appendExpression(expression)
+                appendEOLIfMissing()
+                return
+              default: break
+            }
+          }
+          appendEOL()
+          indent {
+            generateStatements(statements)
+          }
+        }
+        
+        appendIndent()
+        append("switch ")
+        appendExpression(expression)
+        indentedCodeBlock {
+          for pair in pairs {
+            appendIndent()
+            append("case \(string(for: pair.condition)):")
+            generateCaseStatements(pair.statements)
+          }
+          if !def.isEmpty {
+            appendIndent()
+            append("default:")
+            generateCaseStatements(def)
+          }
+        }
       case .ifElseSwitch(let pairs):
         assert(!pairs.isEmpty)
         var isFirst = true

Plugins/Libraries/LighterCodeGenAST/Generation/GenStructures.swift

@@ -7,7 +7,7 @@ public extension CodeGenerator {
 
   /// public static let schema = Schema()
   /// public var personId  : Int
-  func generateInstanceVariable(_    value : Struct.InstanceVariable,
+  func generateInstanceVariable(_    value : TypeDefinition.InstanceVariable,
                                 `static`   : Bool = false,
                                 omitPublic : Bool = false)
   {
@@ -77,7 +77,34 @@ public extension CodeGenerator {
       writePlain()
     }
   }
-  
+
+  /**
+   * ```swift
+   * public struct Person: SQLKeyedTableRecord, Identifiable {
+   *
+   *   public static let schema = Schema()
+   *
+   *   @inlinable
+   *   public var id : Int { personId }
+   *
+   *   public var personId  : Int
+   *   public var lastname  : String
+   *   public var firstname : String?
+   *
+   *   @inlinable
+   *   public init(personId: Int = 0, lastname: String, firstname: String? = nil) {
+   *     self.personId  = personId
+   *     self.lastname  = lastname
+   *     self.firstname = firstname
+   *   }
+   * }
+   * ```
+   */
+  func generateStruct(_ value: TypeDefinition, omitPublic: Bool = false) {
+    assert(value.kind == .struct)
+    generateTypeDefinition(value, omitPublic: omitPublic)
+  }
+
   /**
    * ```swift
    * public struct Person: SQLKeyedTableRecord, Identifiable {
@@ -100,7 +127,8 @@ public extension CodeGenerator {
    * }
    * ```
    */
-  func generateStruct(_ value: Struct, omitPublic: Bool = false) {
+  func generateTypeDefinition(_ value: TypeDefinition, omitPublic: Bool = false)
+  {
     if !source.isEmpty { appendEOLIfMissing() }
 
     if let comment = value.comment {
@@ -113,8 +141,15 @@ public extension CodeGenerator {
 
     do { // header
       appendIndent()
+      assert(!value.final || value.kind == .class)
       if value.public && !omitPublic { append("public ") }
-      append("struct ")
+      if value.final { append("final ") }
+      switch value.kind {
+        case .struct : append("struct ")
+        case .class  : append("class ")
+        case .enum   : append("enum ")
+        case .actor  : append("actor ")
+      }
       append(tickedWhenReserved(value.name))
 
       if !value.conformances.isEmpty {
@@ -129,12 +164,13 @@ public extension CodeGenerator {
 
       if !value.typeAliases.isEmpty { writeln() }
       for ( name, ref ) in value.typeAliases {
-        writeln("\(pubPrefix)typealias \(tickedWhenReserved(name))\(configuration.propertyValueSeparator)\(string(for: ref))")
+        writeln("\(pubPrefix)typealias \(tickedWhenReserved(name))"
+              + "\(configuration.propertyValueSeparator)\(string(for: ref))")
       }
 
-      for structure in value.structures {
+      for nestedType in value.nestedTypes {
         writeln()
-        generateStruct(structure)
+        generateTypeDefinition(nestedType)
       }
 
       // Later: I'd really like to vertically align the colors and equals.

Plugins/Libraries/LighterCodeGenAST/Generation/GenUnit.swift

@@ -1,6 +1,6 @@
 //
 //  Created by Helge Heß.
-//  Copyright © 2022 ZeeZide GmbH.
+//  Copyright © 2022-2024 ZeeZide GmbH.
 //
 
 public extension CodeGenerator {
@@ -18,9 +18,9 @@ public extension CodeGenerator {
       generateFunctionDefinition(function)
     }
 
-    for structure in unit.structures {
+    for typeDefinition in unit.typeDefinitions {
       writeln()
-      generateStruct(structure)
+      generateTypeDefinition(typeDefinition)
     }
 
     for ext in unit.extensions {

Plugins/Libraries/LighterCodeGenAST/Generation/ReservedWords.swift

@@ -1,6 +1,6 @@
 //
 //  Created by Helge Heß.
-//  Copyright © 2022 ZeeZide GmbH.
+//  Copyright © 2022-2024 ZeeZide GmbH.
 //
 
 // hm, this doesn't actually work:
@@ -22,9 +22,9 @@ let SwiftReservedWords : Set<String> = [
   "if", "guard", "else", "switch", "catch", "throw",
   "true", "false", "nil", "self",
   "as", "is",
-  "async", "await",
   "typealias", "associatedtype",
   "associativity", "dynamic", "convenience", "required", "final",
   "didSet", "willSet", "get", "set",
-  "weak", "unowned"
+  "weak", "unowned",
+  "actor", "async", "await", "sending"
 ]

Plugins/Libraries/LighterCodeGenAST/Nodes/CompilationUnit.swift

@@ -1,6 +1,6 @@
 //
 //  Created by Helge Heß.
-//  Copyright © 2022 ZeeZide GmbH.
+//  Copyright © 2022-2024 ZeeZide GmbH.
 //
 
 /**
@@ -20,25 +20,35 @@ public struct CompilationUnit {
   public var reexports  : [ String ] = []
 
   /// The structures that are part of the unit.
-  public var structures : [ Struct ]
+  public var typeDefinitions : [ TypeDefinition ]
   /// The functions that are part of the unit.
-  public var functions  : [ FunctionDefinition ]
+  public var functions       : [ FunctionDefinition ]
   /// The extensions that are part of the unit.
-  public var extensions : [ Extension ]
+  public var extensions      : [ Extension ]
 
   /// Initialize a new CompilationUnit, only name and extensions are required.
-  public init(name       : String,
-              imports    : [ String             ] = [],
-              structures : [ Struct             ] = [],
-              functions  : [ FunctionDefinition ] = [],
-              extensions : [ Extension          ] = [])
+  public init(name            : String,
+              imports         : [ String             ] = [],
+              typeDefinitions : [ TypeDefinition     ] = [],
+              functions       : [ FunctionDefinition ] = [],
+              extensions      : [ Extension          ] = [])
   {
     self.name       = name
     self.imports    = imports
-    self.structures = structures
+    self.typeDefinitions = typeDefinitions
     self.functions  = functions
     self.extensions = extensions
   }
+  /// Initialize a new CompilationUnit, only name and extensions are required.
+  public init(name       : String,
+              imports    : [ String             ] = [],
+              structures : [ TypeDefinition     ], // legacy compat
+              functions  : [ FunctionDefinition ] = [],
+              extensions : [ Extension          ] = [])
+  {
+    self.init(name: name, imports: imports, typeDefinitions: structures,
+              functions: functions, extensions: extensions)
+  }
 }