Update Tile{T, (...)} notation in docstrings (#242)

Author: AntonOresten

src/compiler/analysis/divisibility.jl

@@ -87,7 +87,7 @@ function transfer(a::DivByAnalysis, r::DataflowResult, @nospecialize(func),
     end
 
     # Pointer offset: result is divisible by gcd(ptr_div, off_div * elem_bytes).
-    # The base may be either `Tile{Ptr{T}, ()}` (post-canonicalize tile form)
+    # The base may be either `Tile{Ptr{T}, Tuple{}}` (post-canonicalize tile form)
     # or raw `Ptr{T}` (the SCI annotation on `getfield(arg, :ptr)`); both
     # lower to a 0-D pointer Value at codegen.
     #
@@ -198,7 +198,7 @@ function tilearray_field_divby(ref::TileArrayFieldRef)
 end
 
 # Pointee element type of a 0-D pointer base, accepting both `Ptr{T}` and
-# `Tile{Ptr{T}, ()}`. Returns `nothing` for shapes that don't fit (tile-of-
+# `Tile{Ptr{T}, Tuple{}}`. Returns `nothing` for shapes that don't fit (tile-of-
 # pointers, non-pointer types, …).
 function ptr_pointee(@nospecialize(T))
     if T <: Tile

src/compiler/codegen/kernel.jl

@@ -330,7 +330,7 @@ maps `block_args` to the function's positional arguments, emits the body, and re
 the yielded result values.
 
 - `func`: the Julia function to compile (e.g., `+`, `max`, a lambda)
-- `arg_types`: Julia types for each block arg (e.g., `[Tile{Float32,()}]` repeated)
+- `arg_types`: Julia types for each block arg (e.g., `[Tile{Float32, Tuple{}}]` repeated)
 - `block_args`: IR `Value`s from the enclosing region (e.g., `[acc, elem]`)
 - `block_type_ids`: `TypeId`s corresponding to each block arg
 

src/compiler/intrinsics/random.jl

@@ -18,9 +18,9 @@
 #
 # State-accessor intrinsics take a stream as their first operand:
 #
-#   rng_counter(h)      -> Tile{UInt32, ()}  — read h's counter
+#   rng_counter(h)      -> Tile{UInt32, Tuple{}}  — read h's counter
 #   rng_advance(h, n)   -> Nothing           — add n to h's counter
-#   rng_seed(h)         -> Tile{UInt32, ()}  — read h's seed
+#   rng_seed(h)         -> Tile{UInt32, Tuple{}}  — read h's seed
 #   rng_set_seed(h, s)  -> Nothing           — overwrite h's seed
 
 # ---- allocation ------------------------------------------------------------

src/language/operations.jl

@@ -703,7 +703,7 @@ public arange
 
 """
     arange(shape; dtype=Int32) -> Tile{dtype, shape}
-    arange(n; dtype=Int32) -> Tile{dtype, (n,)}
+    arange(n; dtype=Int32) -> Tile{dtype, Tuple{n}}
 
 Create a 1D tile with values [1, 2, 3, ..., n] (1-indexed).
 
@@ -804,15 +804,15 @@ permuted = permutedims(tile, (3, 1, 2))    # Shape (4, 2, 3)
     Intrinsics.permute(tile, map(p -> p - 1, Perm))
 
 """
-    permutedims(tile::Tile{T, (M, N)}) -> Tile{T, (N, M)}
+    permutedims(tile::Tile{T, Tuple{M, N}}) -> Tile{T, Tuple{N, M}}
 
 Permute a 2D tile, swapping its dimensions. Defaults to permutation `(2, 1)`.
 
 Equivalent to `transpose`.
 
 ---
 
-    permutedims(tile::Tile{T, (N,)}) -> Tile{T, (1, N)}
+    permutedims(tile::Tile{T, Tuple{N}}) -> Tile{T, Tuple{1, N}}
 
 Reshape a 1D tile into a `1 × N` row tile.
 
@@ -832,13 +832,13 @@ Equivalent to `transpose`.
 end
 
 """
-    transpose(tile::Tile{T, (M, N)}) -> Tile{T, (N, M)}
+    transpose(tile::Tile{T, Tuple{M, N}}) -> Tile{T, Tuple{N, M}}
 
 Transpose a 2D tile, swapping its dimensions.
 
 ---
 
-    transpose(tile::Tile{T, (N,)}) -> Tile{T, (1, N)}
+    transpose(tile::Tile{T, Tuple{N}}) -> Tile{T, Tuple{1, N}}
 
 Reshape a 1D tile into a `1 × N` row tile.
 

src/language/types.jl

@@ -236,7 +236,7 @@ end
     Tile{T, Shape}
 
 Represents a tile of data with element type `T` and static shape `Shape`.
-Shape is a tuple of integers representing the tile dimensions.
+Shape is a tuple type encoding the tile dimensions (e.g. `Tuple{16, 32}`).
 
 This is a compile-time abstraction - at runtime in kernel code, tiles are
 represented as Tile IR values. The struct exists to enable proper type