Fix match type usage for Gather op

Author: EmergentOrder

core/src/main/scala/ONNX.scala

@@ -756,30 +756,28 @@ package object onnx {
              Float | Double | String | Boolean |
              Complex[
                Float
-             ] | Complex[Double],
-          @sp Tind <: Int: Numeric, // Spec also supports long
+             ] | Complex[Double], 
           Tt <: TensorTypeDenotation,
           Td <: TensorShapeDenotation,
           S <: Shape,
-          Tt1 <: TensorTypeDenotation,
-          Td1 <: TensorShapeDenotation,
-          S1 <: Shape,
           Tt2 <: TensorTypeDenotation,
           Td2 <: TensorShapeDenotation,
           AxisIndex <: Index ::: INil,
-          AxisIndices <: Indices
+          AxisIndices <: Indices,
+          IndicesSize <: Index
       ](
           name: String,
           axis: AxisIndex = 0 ::: INil,
           data: Tensor[T, Tuple3[Tt, Td, S]],
-          indices: AxisIndices
+          indices: AxisIndices,
+//          indicesSize: IndicesSize[AxisIndices]
       )(using
           tt: ValueOf[Tt2],
           td: TensorShapeDenotationOf[Td2],
-          s: ShapeOf[GatheredShape[S, AxisIndex, AxisIndices]],
+          s: ShapeOf[GatheredShape[S, AxisIndex, AxisIndices, IndicesSize]],
           i: IndicesOf[AxisIndex],
-          i2: IndicesOf[AxisIndices]
-      ): Tensor[T, Tuple3[Tt2, Td2, GatheredShape[S, AxisIndex, AxisIndices]]] = {
+          i2: IndicesOf[AxisIndices],
+          ): Tensor[T, Tuple3[Tt2, Td2, GatheredShape[S, AxisIndex, AxisIndices, IndicesSize]]] = {
          val map: Map[String, Any] = Map("axis" -> indicesOf[AxisIndex].indices.toArray.head)
          val allInputs = Tuple2(
            data,

core/src/main/scala/Tensors.scala

@@ -144,29 +144,32 @@ object Tensors {
    type GatheredShape[
        S <: Shape,
        AxisIndex <: None.type | Indices,
-       AxisIndices <: Indices
+       AxisIndices <: Indices,
+       IndicesSize <: Index
    ] <: Shape = AxisIndex match {
       case None.type => SNil
-      case Indices   => GatheredShapeLoop[S, AxisIndex, 0, AxisIndices]
+      case Indices   => GatheredShapeLoop[S, AxisIndex, 0, AxisIndices, IndicesSize]
    }
 
    protected type GatheredShapeLoop[
        ToGather <: Shape,
        AxisIndex <: Indices,
        I <: Index,
-       AxisIndices <: Indices
+       AxisIndices <: Indices,
+       IndicesSize <: Index
    ] <: Shape = ToGather match {
       case head #: tail =>
          Indices.Contains[AxisIndex, I] match {
-            case true =>
-               IndicesSize[AxisIndices] #:
+           case true =>
+               IndicesSize #: 
                   GatheredShapeLoop[
                     tail,
                     Indices.RemoveValue[AxisIndex, I],
                     S[I],
-                    AxisIndices
+                    AxisIndices,
+                    IndicesSize
                   ]
-            case false => head #: GatheredShapeLoop[tail, AxisIndex, S[I], AxisIndices]
+            case false => head #: GatheredShapeLoop[tail, AxisIndex, S[I], AxisIndices, IndicesSize]
          }
       case SNil =>
          AxisIndex match {
@@ -176,12 +179,12 @@ object Tensors {
          }
    }
 
-   type IndicesSize[AxisIndices <: Indices] = IndicesSizeLoop[AxisIndices, 0]
+   type IndicesSizeOf[AxisIndices <: Indices] = IndicesSizeLoop[AxisIndices, 0]
 
-   type IndicesSizeLoop[AxisIndices <: Indices, Acc <: Dimension] = AxisIndices match {
-      case head ::: tail => IndicesSizeLoop[tail, S[Acc]]
-      case INil          => Acc
-   }
+   protected type IndicesSizeLoop[AxisIndices <: Indices, Acc <: Dimension] <: Index = AxisIndices match {
+       case head ::: tail => IndicesSizeLoop[tail, S[Acc]]
+       case INil          => Acc
+    }
 
    type FlattenedShape[S <: Shape, AxisIndex <: None.type | Indices] <: Shape = AxisIndex match {
       case None.type => SNil