nitrogen 0.31.1 → 0.31.3

package/src/syntax/kotlin/KotlinStruct.ts

@@ -7,29 +7,44 @@ import type { SourceFile } from '../SourceFile.js'
 import type { StructType } from '../types/StructType.js'
 import { KotlinCxxBridgedType } from './KotlinCxxBridgedType.js'
 
+interface BridgedProperty {
+  name: string
+  type: KotlinCxxBridgedType
+}
+
 export function createKotlinStruct(structType: StructType): SourceFile[] {
   const packageName = NitroConfig.current.getAndroidPackage('java/kotlin')
-  const parameters = structType.properties
-    .map((p) =>
-      `
+
+  const bridgedProperties = structType.properties.map<BridgedProperty>((p) => ({
+    name: p.escapedName,
+    type: new KotlinCxxBridgedType(p),
+  }))
+  //   const parameters = structType.properties
+  //     .map((p) =>
+  //       `
+  // @DoNotStrip
+  // @Keep
+  // val ${p.escapedName}: ${p.getCode('kotlin')}
+  // `.trim()
+  //     )
+  //     .join(',\n')
+  const properties = bridgedProperties
+    .map(({ name, type }) => {
+      return `
 @DoNotStrip
 @Keep
-val ${p.escapedName}: ${p.getCode('kotlin')}
+val ${name}: ${type.getTypeCode('kotlin', false)}
 `.trim()
-    )
+    })
     .join(',\n')
 
-  const cxxCreateFunctionParameters = structType.properties
-    .map((p) => {
-      const bridged = new KotlinCxxBridgedType(p)
-      return `${p.escapedName}: ${bridged.getTypeCode('kotlin', false)}`
+  const cxxCreateFunctionParameters = bridgedProperties
+    .map(({ name, type }) => {
+      return `${name}: ${type.getTypeCode('kotlin', false)}`
     })
     .join(', ')
-  const cxxCreateFunctionForward = structType.properties
-    .map((p) => {
-      const bridged = new KotlinCxxBridgedType(p)
-      return bridged.parseFromCppToKotlin(p.escapedName, 'kotlin', false)
-    })
+  const cxxCreateFunctionForward = bridgedProperties
+    .map((p) => p.name)
     .join(', ')
 
   const extraImports = structType.properties
@@ -37,6 +52,8 @@ val ${p.escapedName}: ${p.getCode('kotlin')}
     .map((i) => `import ${i.name}`)
     .filter(isNotDuplicate)
 
+  const secondaryConstructor = createKotlinConstructor(structType)
+
   const code = `
 ${createFileMetadataString(`${structType.structName}.kt`)}
 
@@ -52,8 +69,10 @@ ${extraImports.join('\n')}
 @DoNotStrip
 @Keep
 data class ${structType.structName}(
-  ${indent(parameters, '  ')}
+  ${indent(properties, '  ')}
 ) {
+  ${indent(secondaryConstructor, '  ')}
+
   private companion object {
     /**
      * Constructor called from C++
@@ -150,6 +169,33 @@ namespace ${cxxNamespace} {
   return files
 }
 
+function createKotlinConstructor(structType: StructType): string {
+  const bridgedProperties = structType.properties.map<BridgedProperty>((p) => ({
+    name: p.escapedName,
+    type: new KotlinCxxBridgedType(p),
+  }))
+  const needsSpecialHandling = bridgedProperties.some(
+    ({ type }) => type.needsSpecialHandling
+  )
+  if (needsSpecialHandling) {
+    const kotlinParams = structType.properties.map(
+      (p) => `${p.escapedName}: ${p.getCode('kotlin')}`
+    )
+    const paramsForward = bridgedProperties.map(({ name, type }) =>
+      type.parseFromKotlinToCpp(name, 'kotlin')
+    )
+    return `
+/**
+ * Create a new instance of ${structType.structName} from Kotlin
+ */
+constructor(${kotlinParams.join(', ')}):
+       this(${paramsForward.join(', ')})
+      `.trim()
+  } else {
+    return `/* primary constructor */`
+  }
+}
+
 function createJNIStructInitializer(structType: StructType): string {
   const lines: string[] = ['static const auto clazz = javaClassStatic();']
   for (const prop of structType.properties) {

package/src/syntax/swift/SwiftCxxBridgedType.ts

@@ -32,7 +32,6 @@ import { NamedWrappingType } from '../types/NamedWrappingType.js'
 import { ErrorType } from '../types/ErrorType.js'
 import { createSwiftFunctionBridge } from './SwiftFunction.js'
 import type { Language } from '../../getPlatformSpecs.js'
-import { isPrimitivelyCopyable } from './isPrimitivelyCopyable.js'
 
 // TODO: Remove enum bridge once Swift fixes bidirectional enums crashing the `-Swift.h` header.
 
@@ -490,20 +489,8 @@ export class SwiftCxxBridgedType implements BridgedType<'swift', 'c++'> {
         const wrapping = new SwiftCxxBridgedType(array.itemType, true)
         switch (language) {
           case 'swift':
-            if (isPrimitivelyCopyable(array.itemType)) {
-              // We can primitively copy the data, raw:
-              const bridge = this.getBridgeOrThrow()
-              const getDataFunc = `bridge.get_data_${bridge.specializationName}`
-              return `
-{ () -> ${array.getCode('swift')} in
-  let __data = ${getDataFunc}(${cppParameterName})
-  let __size = ${cppParameterName}.size()
-  return Array(UnsafeBufferPointer(start: __data, count: __size))
-}()`.trim()
-            } else {
-              // We have to iterate the element one by one to create a resulting Array (mapped)
-              return `${cppParameterName}.map({ __item in ${wrapping.parseFromCppToSwift('__item', 'swift')} })`.trim()
-            }
+            // We have to iterate the element one by one to create a resulting Array (mapped)
+            return `${cppParameterName}.map({ __item in ${wrapping.parseFromCppToSwift('__item', 'swift')} })`.trim()
           default:
             return cppParameterName
         }
@@ -764,17 +751,9 @@ case ${i}:
         const wrapping = new SwiftCxxBridgedType(array.itemType, true)
         switch (language) {
           case 'swift':
-            if (isPrimitivelyCopyable(array.itemType)) {
-              // memory can be copied primitively
-              const copyFunc = `bridge.${bridge.funcName}`
-              return `
-${swiftParameterName}.withUnsafeBufferPointer { __pointer -> bridge.${bridge.specializationName} in
-  return ${copyFunc}(__pointer.baseAddress!, ${swiftParameterName}.count)
-}`.trim()
-            } else {
-              // array has to be iterated and converted one-by-one
-              const makeFunc = `bridge.${bridge.funcName}`
-              return `
+            // array has to be iterated and converted one-by-one
+            const makeFunc = `bridge.${bridge.funcName}`
+            return `
 { () -> bridge.${bridge.specializationName} in
   var __vector = ${makeFunc}(${swiftParameterName}.count)
   for __item in ${swiftParameterName} {
@@ -782,7 +761,6 @@ ${swiftParameterName}.withUnsafeBufferPointer { __pointer -> bridge.${bridge.spe
   }
   return __vector
 }()`.trim()
-            }
           default:
             return swiftParameterName
         }

package/src/syntax/swift/SwiftCxxTypeHelper.ts

@@ -19,7 +19,6 @@ import { VoidType } from '../types/VoidType.js'
 import { NamedWrappingType } from '../types/NamedWrappingType.js'
 import { ErrorType } from '../types/ErrorType.js'
 import { ResultWrappingType } from '../types/ResultWrappingType.js'
-import { isPrimitivelyCopyable } from './isPrimitivelyCopyable.js'
 
 export interface SwiftCxxHelper {
   cxxHeader: {
@@ -268,26 +267,8 @@ function createCxxVectorSwiftHelper(type: ArrayType): SwiftCxxHelper {
   const actualType = type.getCode('c++')
   const bridgedType = new SwiftCxxBridgedType(type)
   const name = escapeCppName(actualType)
-  let code: string
-  let funcName: string
-  if (isPrimitivelyCopyable(type.itemType)) {
-    const itemType = type.itemType.getCode('c++')
-    funcName = `copy_${name}`
-    code = `
-/**
- * Specialized version of \`${escapeComments(actualType)}\`.
- */
-using ${name} = ${actualType};
-inline ${actualType} copy_${name}(const ${itemType}* CONTIGUOUS_MEMORY NON_NULL data, size_t size) noexcept {
-  return margelo::nitro::FastVectorCopy<${itemType}>(data, size);
-}
-inline const ${itemType}* CONTIGUOUS_MEMORY NON_NULL get_data_${name}(const ${actualType}& vector) noexcept {
-  return vector.data();
-}
-`.trim()
-  } else {
-    funcName = `create_${name}`
-    code = `
+  const funcName = `create_${name}`
+  const code = `
 /**
  * Specialized version of \`${escapeComments(actualType)}\`.
  */
@@ -297,7 +278,6 @@ inline ${actualType} create_${name}(size_t size) noexcept {
   vector.reserve(size);
   return vector;
 }`.trim()
-  }
 
   return {
     cxxType: actualType,
@@ -311,11 +291,6 @@ inline ${actualType} create_${name}(size_t size) noexcept {
           space: 'system',
           language: 'c++',
         },
-        {
-          name: 'NitroModules/FastVectorCopy.hpp',
-          space: 'system',
-          language: 'c++',
-        },
         ...bridgedType.getRequiredImports('c++'),
       ],
     },

package/src/syntax/swift/SwiftHybridObject.ts

@@ -11,7 +11,7 @@ export function createSwiftHybridObject(spec: HybridObjectSpec): SourceFile[] {
   const name = getHybridObjectName(spec.name)
   const protocolName = name.HybridTSpec
   const properties = spec.properties.map((p) => p.getCode('swift')).join('\n')
-  const methods = spec.methods.map((p) => p.getCode('swift')).join('\n')
+  const methods = spec.methods.map((m) => m.getCode('swift')).join('\n')
   const extraImports = [
     ...spec.properties.flatMap((p) => p.getRequiredImports('swift')),
     ...spec.methods.flatMap((m) => m.getRequiredImports('swift')),
@@ -83,6 +83,13 @@ public protocol ${protocolName}_protocol: ${protocolBaseClasses.join(', ')} {
   ${indent(methods, '  ')}
 }
 
+public extension ${protocolName}_protocol {
+  /// Default implementation of \`\`HybridObject.toString\`\`
+  func toString() -> String {
+    return "[HybridObject ${name.T}]"
+  }
+}
+
 /// See \`\`${protocolName}\`\`
 open class ${protocolName}_base${classBaseClasses.length > 0 ? `: ${classBaseClasses.join(',')}` : ''} {
   ${indent(baseMembers.join('\n'), '  ')}

package/src/syntax/swift/SwiftHybridObjectBridge.ts

@@ -191,7 +191,7 @@ ${hasBase ? `open class ${name.HybridTSpecCxx} : ${baseClasses.join(', ')}` : `o
    */
   public func getCxxPart() -> bridge.${bridge.specializationName} {
     let cachedCxxPart = self.__cxxPart.lock()
-    if cachedCxxPart.__convertToBool() {
+    if Bool(fromCxx: cachedCxxPart) {
       return cachedCxxPart
     } else {
       let newCxxPart = bridge.${bridge.funcName}(self.toUnsafe())
@@ -220,6 +220,14 @@ ${hasBase ? `open class ${name.HybridTSpecCxx} : ${baseClasses.join(', ')}` : `o
     self.__implementation.dispose()
   }
 
+  /**
+   * Call toString() on the Swift class.
+   */
+  @inline(__always)
+  public ${hasBase ? 'override func' : 'func'} toString() -> String {
+    return self.__implementation.toString()
+  }
+
   // Properties
   ${indent(propertiesBridge.join('\n\n'), '  ')}
 
@@ -390,6 +398,9 @@ namespace ${cxxNamespace} {
     void dispose() noexcept override {
       _swiftPart.dispose();
     }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
 
   public:
     // Properties

package/src/syntax/types/{HybridObjectBaseType.ts → AnyHybridObjectType.ts}

@@ -3,7 +3,7 @@ import { getForwardDeclaration } from '../c++/getForwardDeclaration.js'
 import type { SourceFile, SourceImport } from '../SourceFile.js'
 import type { Type, TypeKind } from './Type.js'
 
-export class HybridObjectBaseType implements Type {
+export class AnyHybridObjectType implements Type {
   constructor() {}
 
   get canBePassedByReference(): boolean {
@@ -21,7 +21,7 @@ export class HybridObjectBaseType implements Type {
         return `std::shared_ptr<HybridObject>`
       default:
         throw new Error(
-          `The base type \`HybridObject\` cannot be used directly in ${language} yet. Use a specific derived class of \`HybridObject\` instead!`
+          `\`AnyHybridObject\` cannot be used directly in ${language} yet. Use a specific derived class of \`HybridObject\` instead!`
         )
     }
   }
@@ -50,13 +50,6 @@ export class HybridObjectBaseType implements Type {
           }
         )
         break
-      case 'kotlin':
-        imports.push({
-          name: 'com.margelo.nitro.core.HybridObject',
-          space: 'system',
-          language: 'kotlin',
-        })
-        break
     }
     return imports
   }

package/src/utils.ts

@@ -7,8 +7,6 @@ import { isNotDuplicate } from './syntax/helpers.js'
 import { readUserConfig } from './config/getConfig.js'
 import { NitroConfig } from './config/NitroConfig.js'
 
-export const NITROGEN_VERSION = process.env.npm_package_version ?? '?.?.?'
-
 export function capitalizeName(name: string): string {
   if (name.length === 0) return name
   return name.charAt(0).toUpperCase() + name.slice(1)

package/src/syntax/swift/isPrimitivelyCopyable.ts

@@ -1,20 +0,0 @@
-import type { Type } from '../types/Type.js'
-
-/**
- * Returns `true` if the given {@linkcode type} is a datatype that
- * can be copied without running a copy constructor or special logic
- * to copy the data over. In other words; it's _primitively copyable_.
- */
-export function isPrimitivelyCopyable(type: Type): boolean {
-  switch (type.kind) {
-    case 'number':
-    case 'boolean':
-    case 'bigint':
-    case 'enum':
-    case 'null':
-    case 'void':
-      return true
-    default:
-      return false
-  }
-}