Remove Send and Receive

build.sc

@@ -51,7 +51,6 @@ object core
     with PublishableModule
     with FacadeGenerationModule
     with BenchmarksModule {
-
   def javacOptions =
     super.javacOptions() ++ Seq("--release", "17")
 
@@ -62,8 +61,7 @@ object core
       "-project", "slinc"
     )
   }
-
-
+
   def pomSettings = pomTemplate("slinc-core")
 
   def specializationArity = 4

core/src/fr/hammons/slinc/LibraryI.scala

@@ -31,6 +31,10 @@ object LibraryI:
         descriptor: FunctionDescriptor
     ): MethodHandle
 
+    def getDowncall(
+        descriptor: FunctionDescriptor
+    ): MethodHandle
+
     def getLocalLookup(name: String): Lookup
     def getLibraryPathLookup(name: String): Lookup
     def getStandardLibLookup: Lookup

core/src/fr/hammons/slinc/MethodHandleTools.scala

@@ -157,14 +157,15 @@ object MethodHandleTools:
     calculateMethodHandleImplementation[L]('platformSpecific, 'addresses)
   }
 
-  inline def wrappedMH[A](methodHandle: MethodHandle) = ${
-    wrappedMHImpl[A]('methodHandle)
+  inline def wrappedMH[A](mem: Mem, methodHandle: MethodHandle) = ${
+    wrappedMHImpl[A]('mem, 'methodHandle)
   }
 
   // todo: get rid of this once bug https://github.com/lampepfl/dotty/issues/16863 is fixed
   @nowarn("msg=unused implicit parameter")
   @nowarn("msg=unused local definition")
   private def wrappedMHImpl[A](
+      mem: Expr[Mem],
       methodHandleExpr: Expr[MethodHandle]
   )(using Quotes, Type[A]) =
     import quotes.reflect.*
@@ -176,7 +177,7 @@ object MethodHandleTools:
 
     val paramNames = LazyList.iterate("a")(a => a ++ a)
 
-    Lambda(
+    val expr = Lambda(
       Symbol.spliceOwner,
       MethodType(paramNames.take(inputTypes.size).toList)(
         _ => inputTypes,
@@ -187,7 +188,8 @@ object MethodHandleTools:
           case '[r] =>
             val invokeExpr = invokeArguments[r](
               methodHandleExpr,
-              params.map(_.asExpr)
+              '{ $mem.asBase } +:
+                params.map(_.asExpr)
             )
             val invokeResultExpr = '{
               val invokeResult = $invokeExpr
@@ -197,3 +199,5 @@ object MethodHandleTools:
             invokeResultExpr.asTerm
               .changeOwner(meth)
     ).asExprOf[A]
+
+    expr

core/src/fr/hammons/slinc/Ptr.scala

@@ -2,15 +2,30 @@ package fr.hammons.slinc
 
 import scala.reflect.ClassTag
 import fr.hammons.slinc.modules.DescriptorModule
+import fr.hammons.slinc.modules.ReadWriteModule
+
+import scala.compiletime.summonFrom
 
 class Ptr[A](private[slinc] val mem: Mem, private[slinc] val offset: Bytes):
-  def `unary_!`(using receive: Receive[A]): A = receive.from(mem, offset)
+  inline def `unary_!`(using rwm: ReadWriteModule): A = summonFrom {
+    case descO: DescriptorOf[A] => rwm.read(mem, offset)
+    case f: Fn[A, ?, ?] =>
+      rwm.readFn(
+        mem,
+        FunctionDescriptor.fromFunction[A],
+        mh => MethodHandleTools.wrappedMH[A](_, mh)
+      )
+  }
+
   def asArray(size: Int)(using DescriptorOf[A], DescriptorModule)(using
-      r: ReceiveBulk[A]
-  ) =
-    r.from(mem.resize(DescriptorOf[A].size * size), offset, size)
+      r: ReadWriteModule
+  ): IArray[A] =
+    IArray.unsafeFromArray(
+      r.readArray(mem.resize(DescriptorOf[A].size * size), offset, size)
+    )
 
-  def `unary_!_=`(value: A)(using send: Send[A]) = send.to(mem, offset, value)
+  def `unary_!_=`(value: A)(using rwM: ReadWriteModule)(using DescriptorOf[A]) =
+    rwM.write(mem, offset, value)
   def apply(bytes: Bytes): Ptr[A] = Ptr[A](mem, offset + bytes)
   def apply(index: Int)(using DescriptorOf[A], DescriptorModule): Ptr[A] =
     Ptr[A](mem, offset + (DescriptorOf[A].size * index))
@@ -23,7 +38,7 @@ object Ptr:
   extension (p: Ptr[Byte])
     def copyIntoString(
         maxSize: Int
-    )(using DescriptorOf[Byte], DescriptorModule) =
+    )(using DescriptorOf[Byte], DescriptorModule, ReadWriteModule) =
       var i = 0
       val resizedPtr = p.resize(Bytes(maxSize))
       while (i < maxSize && !resizedPtr(i) != 0) do i += 1
@@ -39,21 +54,21 @@ object Ptr:
 
   def copy[A](
       a: Array[A]
-  )(using alloc: Allocator, descriptor: DescriptorOf[A], send: Send[Array[A]]) =
+  )(using alloc: Allocator, descriptor: DescriptorOf[A], rwm: ReadWriteModule) =
     val mem = alloc.allocate(DescriptorOf[A], a.size)
-    send.to(mem, Bytes(0), a)
+    rwm.writeArray(mem, Bytes(0), a)
     Ptr[A](mem, Bytes(0))
 
   def copy[A](using alloc: Allocator)(
       a: A
-  )(using send: Send[A], descriptor: DescriptorOf[A]) =
+  )(using rwm: ReadWriteModule, descriptor: DescriptorOf[A]) =
     val mem = alloc.allocate(DescriptorOf[A], 1)
-    send.to(mem, Bytes(0), a)
+    rwm.write(mem, Bytes(0), a)
     Ptr[A](mem, Bytes(0))
 
   def copy(
       string: String
-  )(using Allocator, DescriptorOf[Byte], Send[Array[Byte]]): Ptr[Byte] = copy(
+  )(using Allocator, DescriptorOf[Byte], ReadWriteModule): Ptr[Byte] = copy(
     string.getBytes("ASCII").nn :+ 0.toByte
   )
 

core/src/fr/hammons/slinc/Scope.scala

@@ -1,7 +1,5 @@
 package fr.hammons.slinc
 
-import scala.annotation.experimental
-
 sealed trait Scope:
   def apply[A](fn: Allocator ?=> A): A