More fixes for compatibility with Embedded Swift.

The change improves compatibility with Embedded Swift. Specifically:
1. Cleans up accessors for properties to avoid use of property wrappers, which allows binary size to be slightly reduced.
2. Fixes dictionary-like types that previously had incorrect initializers not inheriting properties from superclasses.

Author: MaxDesiatov

Sources/WebIDLToSwift/WebIDL+SwiftRepresentation.swift

@@ -71,59 +71,90 @@ extension IDLDictionary.Member {
     }
 }
 
-extension MergedDictionary: SwiftRepresentable {
+extension IDLDictionary.Member: SwiftRepresentable {
     var swiftRepresentation: SwiftSource {
-        """
-        public class \(name): BridgedDictionary {
-            \(swiftInit)
-            \(swiftMembers.joined(separator: "\n\n"))
+        if ModuleState.override {
+            assert(!ModuleState.static)
+            return ""
+        } else {
+            let stringKey = ModuleState.source(for: name)
+            let getter: SwiftSource
+            let setter: SwiftSource
+
+            if let closure = idlType.closurePattern {
+                getter = "get { \(closure.getter(name: stringKey)) }"
+                setter = "set { \(closure.setter(name: stringKey)) }"
+            } else {
+                getter = "get { jsObject[\(stringKey)]\(idlType.fromJSValue) }"
+                setter = "set { jsObject[\(stringKey)] = _toJSValue(newValue) }"
+            }
+
+            return """
+                @inlinable public\(raw: ModuleState.static ? " static" : "") var \(name): \(idlType) {
+                    \(getter)
+                    \(setter)
+                }
+                """
         }
-        """
     }
+}
 
-    private func membersWithPropertyWrapper(_ members: [IDLDictionary.Member]) -> [(IDLDictionary.Member, SwiftSource)] {
-        members.map {
-            ($0, $0.idlType.propertyWrapper(readonly: false))
-        }
+extension MergedDictionary: SwiftRepresentable {
+    var swiftRepresentation: SwiftSource {
+        let inheritanceClause: SwiftSource =
+            if self.inheritance.isEmpty {
+                ": JSDictionaryCompatible"
+            } else {
+                ": \(self.inheritance.joined(separator: ", "))"
+            }
+
+        return """
+            open class \(name)\(inheritanceClause) {
+                \(self.inheritance.isEmpty ? "public let jsObject: JSObject" : "")
+
+                \(swiftInit)
+
+                \(lines: self.members.map(\.swiftRepresentation))
+            }
+            """
     }
 
-    private var swiftInit: SwiftSource {
-        let params: [SwiftSource] = members.map {
-            "\($0.name): \($0.idlType.isFunction ? "@escaping " : "")\($0.idlType)"
+    private var convenienceInit: SwiftSource {
+        let inheritedMembers: [IDLDictionary.Member] = self.inheritance.reduce(into: []) {
+            // FIXME: if dictionary is not found in the current module, it's coming from a dependency,
+            // but for now we have to skip it, since `ModuleState` doesn't seem to handle dependencies.
+            return $0.append(contentsOf: ModuleState.dictionaries[$1]?.members ?? [])
+        }
+
+        let params: [SwiftSource] = (inheritedMembers + members).map {
+            let escaping = if let closurePattern = $0.idlType.closurePattern {
+                closurePattern.nullable || $0.isOptional ? "" : "@escaping "
+            } else { "" }
+            return "\($0.name): \(escaping)\($0.idlType)\($0.isOptional ? "? = nil" : "")"
         }
+
         return """
         public convenience init(\(sequence: params)) {
             let object = JSObject.global[\(ModuleState.source(for: "Object"))].function!.new()
-            \(lines: membersWithPropertyWrapper(members).map { member, wrapper in
-                if member.idlType.isFunction {
-                    return """
-                    \(wrapper)[\(ModuleState.source(for: member.name)), in: object] = \(member.name)
-                    """
-                } else {
+            \(lines: (inheritedMembers + members).map { member in
                     return """
                     object[\(ModuleState.source(for: member.name))] = _toJSValue(\(member.name))
                     """
-                }
             })
-            self.init(unsafelyWrapping: object)
-        }
 
-        public required init(unsafelyWrapping object: JSObject) {
-            \(lines: membersWithPropertyWrapper(members).map { member, wrapper in
-                "_\(raw: member.name) = \(wrapper)(jsObject: object, name: \(ModuleState.source(for: member.name)))"
-            })
-            super.init(unsafelyWrapping: object)
+            self.init(unsafelyWrapping: object)
         }
         """
     }
 
-    private var swiftMembers: [SwiftSource] {
-        self.membersWithPropertyWrapper(members).map { member, wrapper in
-            """
-            @\(wrapper)
-            public var \(member.name): \(member.idlType)\(member.optionalSuffix)
+    private var swiftInit: SwiftSource {
+        return """
+            \(self.convenienceInit)
+
+            public required init(unsafelyWrapping object: JSObject) {
+                \(self.inheritance.isEmpty ? "self.jsObject = object" : "super.init(unsafelyWrapping: object)")
+            }
             """
-        }
     }
 }
 
@@ -765,8 +796,8 @@ extension IDLTypedef: SwiftRepresentable {
                 unionType.friendlyName = name
                 return ""
             }
-        }
-        return "public typealias \(name) = \(idlType)"
+        } else if let type = Self.typeNameMap[name] { aliasedType = type } else { aliasedType = "\(idlType)" }
+        return "public typealias \(name) = \(aliasedType)"
     }
 }
 

Sources/WebIDLToSwift/WebIDLToSwift.swift

@@ -11,7 +11,7 @@ enum WebIDLToSwift {
 
     static func main() {
         do {
-            let mode = parseArgs()
+            let (mode, moduleNames) = parseArgs()
             let packageDir = URL(fileURLWithPath: #file)
                 .deletingLastPathComponent()
                 .deletingLastPathComponent()
@@ -22,6 +22,9 @@ enum WebIDLToSwift {
             // Collect closure patterns from all modules to subsequently write them together with `baseModule`.
             var closurePatterns = Set<ClosurePattern>()
 
+            let modules = if moduleNames.isEmpty { modules } else {
+                modules.filter { moduleNames.contains($0.swiftModule) }
+            }
             for module in modules {
                 try generate(module, packageDir: packageDir, domTypes: domTypes, patch: mode != .noPatch)
                 closurePatterns.formUnion(ModuleState.closurePatterns)
@@ -39,8 +42,9 @@ enum WebIDLToSwift {
         }
     }
 
-    private static func parseArgs() -> Mode? {
+    private static func parseArgs() -> (Mode?, moduleNames: [String]) {
         var mode: Mode?
+        var moduleNames = [String]()
         for arg in CommandLine.arguments.dropFirst() {
             if arg.starts(with: "--") {
                 if let parsed = Mode(rawValue: String(arg.dropFirst(2))) {
@@ -49,10 +53,10 @@ enum WebIDLToSwift {
                     print("Unknown option: \(arg)")
                 }
             } else {
-                print("Unknown argument: \(arg)")
+                moduleNames.append(arg)
             }
         }
-        return mode
+        return (mode, moduleNames)
     }
 
     private static func generate(