carray-jit 0.1.2 → 0.1.4

data/lib/carray/jit/analyzer.rb

@@ -12,6 +12,96 @@ class CArray
     # so the caller passes them in -- it knows, because it has the values.
     class Analyzer
 
+      # ---- the vocabulary a local array is written in ----
+
+      # The types a body may make an array of: CArray's own constructor names,
+      # each naming the storage type CArray gives it.  Taken from CArray
+      # rather than invented here, which is why the aliases land where they
+      # do -- `CArray.float` is a float32 and `CArray.complex` is a cmplx64,
+      # the opposite of what Ruby's own Float and Complex would suggest.
+      LOCAL_ARRAY_TYPES = {
+        :int8     => "int8",     :int16    => "int16",
+        :int32    => "int32",    :int64    => "int64",
+        :uint8    => "uint8",    :uint16   => "uint16",
+        :uint32   => "uint32",   :uint64   => "uint64",
+        :float32  => "float32",  :float64  => "float64",
+        :cmplx64  => "cmplx64",  :cmplx128 => "cmplx128",
+        :boolean  => "boolean",
+        # The aliases, as CArray spells them.
+        :float    => "float32",  :double   => "float64",
+        :complex  => "cmplx64",  :dcomplex => "cmplx128",
+        :byte     => "uint8",    :short    => "int16",
+        :int      => "int32",
+      }.freeze
+
+      # What one cell of each takes, which is what the limits below are
+      # counted in.  Beside the table above so that a type added to one is
+      # visibly missing from the other.
+      LOCAL_ARRAY_STORAGE_BYTES = {
+        "int8" => 1, "int16" => 2, "int32" => 4, "int64" => 8,
+        "uint8" => 1, "uint16" => 2, "uint32" => 4, "uint64" => 8,
+        "float32" => 4, "float64" => 8,
+        "cmplx64" => 8, "cmplx128" => 16,
+        "boolean" => 1,
+      }.freeze
+
+      # How much of a local array a stack frame is asked to hold.  Past
+      # either number the array is allocated at the kernel's entry instead --
+      # so these say where the array goes rather than whether it is allowed,
+      # and nothing is refused for its size.
+      #
+      # Both are provisional: what a Ruby thread's stack actually is on each
+      # platform has not been measured, and until it has, these are a guess
+      # with room under it.  They are in one place so that measuring moves
+      # one number rather than several.  What the total does not count is in
+      # docs: a pasted function's own arrays, recursion, and whatever a
+      # future thread pool gives its threads.
+      LOCAL_ARRAY_BYTE_LIMIT = 4 * 1024
+      LOCAL_ARRAY_TOTAL_BYTE_LIMIT = 16 * 1024
+
+      # The types CArray has that a kernel computes with neither of, and what
+      # each of them holds instead -- which is what the refusal says.
+      LOCAL_ARRAY_REFUSED_TYPES_HOLD = {
+        :object => "Ruby objects",
+        :fixlen => "fixed-length byte strings",
+      }.freeze
+      LOCAL_ARRAY_REFUSED_TYPES = LOCAL_ARRAY_REFUSED_TYPES_HOLD.keys.freeze
+
+      # CArray's compatibility layer, which `data_type_extension.rb` opens by
+      # calling itself "Numo / NumPy-style" and "not the 'main' carray API".
+      # The words inside a block are carray's own, so these are sent to the
+      # spelling they stand for rather than taken.
+      LOCAL_ARRAY_COMPATIBILITY_NAMES = [:zeros, :ones, :full].freeze
+
+      # Every name a constructor may be written under, so that the receiver of
+      # one is known for what it is before anything else has been read.
+      LOCAL_ARRAY_CONSTRUCTOR_NAMES =
+        (LOCAL_ARRAY_TYPES.keys + LOCAL_ARRAY_REFUSED_TYPES +
+         LOCAL_ARRAY_COMPATIBILITY_NAMES + [:new, :empty]).freeze
+
+      # `CArray`, `::CArray`, or one of the type classes under either.  A
+      # constructor is written on one of these and on nothing else.
+      def self.carray_receiver? (node)
+        case node
+        when Prism::ConstantReadNode
+          node.name == :CArray
+        when Prism::ConstantPathNode
+          text = node.slice
+          text == "::CArray" ||
+            text.start_with?("CArray::") || text.start_with?("::CArray::")
+        else
+          false
+        end
+      end
+
+      # Whether this call is one a body would make an array with -- including
+      # the spellings that are refused, so that each is refused by the reader
+      # that knows why rather than by the capture scan.
+      def self.local_array_constructor? (node)
+        node.is_a?(Prism::CallNode) && carray_receiver?(node.receiver) &&
+          LOCAL_ARRAY_CONSTRUCTOR_NAMES.include?(node.name)
+      end
+
       # Ruby Math methods that correspond 1:1 to a math.h function.
       #
       # Deliberately excludes anything whose C counterpart disagrees on
@@ -35,6 +125,11 @@ class CArray
         :cosh  => "cosh",
         :tanh  => "tanh",
         :hypot => "hypot",
+        :erf   => "erf",
+        :erfc  => "erfc",
+        # Not lowered to `tgamma` but to a helper, `Math.gamma` being what
+        # Ruby computes and tgamma only most of it -- see CGenerator.
+        :gamma => "gamma",
         :asinh => "asinh",
         :acosh => "acosh",
         :atanh => "atanh",
@@ -101,12 +196,25 @@ class CArray
         :rad_pi  => "no math.h counterpart",
       }.freeze
 
+      # Ruby's other ways of counting a loop.  Each is a loop this could run,
+      # and each is refused by name rather than by the generic message, so
+      # that the answer is the spelling to use rather than a list to search.
+      INNER_LOOP_SPELLINGS = %i[downto upto reverse_each each_with_index
+                                each_with_object].freeze
+
+      # The two questions about a number that answer true or false in Ruby,
+      # and that C answers with a macro of its own.  What each accepts is
+      # Ruby's business and is checked with the types: `nan?` is Float's
+      # alone, while `finite?` answers for an Integer and a Complex too.
+      NUMERIC_PREDICATES = %i[nan? finite?].freeze
+
       ARITHMETIC_OPERATORS = [:+, :-, :*, :/, :%].freeze
       # Ruby's bit operators on Integers, which C has too.  What they do at
-      # the edges is C's answer rather than Ruby's -- a shift wraps and takes
-      # its count modulo the width, because CArray's own `<<` compiles to the
-      # same C shift (`ext/mkkernel.rb`, :bit_lshift) and this has to agree
-      # with CArray.
+      # the edges is C's answer rather than Ruby's -- a shift wraps, and a
+      # count of 64 or more or below zero is C's undefined one.  The width is
+      # the kernel's, int64, not the cell's: CArray's own `<<` shifts an int32
+      # in 32 bits (`ext/mkkernel.rb`, :bit_lshift), so past the cell's width
+      # the two part, and the kernel is the one that agrees with a Ruby loop.
       BIT_OPERATORS = [:&, :|, :^, :<<, :>>].freeze
 
       # Methods whose result type is a property of the method: Float#floor and
@@ -134,13 +242,28 @@ class CArray
         :phase     => :arg,
       }.freeze
 
+      # The rest of Ruby's Math, and why each is not lowered.  C has a
+      # function by every one of these names -- saying it does not would be
+      # untrue, and it was what this said until the list was read against
+      # `math.h` -- so the reason is the one that actually applies: what
+      # Ruby computes and what C computes are not the same thing.
+      REFUSED_MATH = {
+        :lgamma => "Ruby's answer is a pair -- the value and the sign -- " \
+                   "and a cell holds one number",
+        :frexp  => "Ruby's answer is a pair -- the fraction and the " \
+                   "exponent -- and a cell holds one number",
+        :ldexp  => "its second argument is an exponent rather than a " \
+                   "number, and a math call here computes every argument " \
+                   "in the type of its result",
+      }.freeze
+
       # Constants under Math, emitted as literals so that the C sees exactly
       # the double Ruby would have used.
       MATH_CONSTANTS = { :PI => Math::PI, :E => Math::E }.freeze
       COMPARISON_OPERATORS = [:<, :<=, :>, :>=, :==, :!=].freeze
 
       attr_reader :parameter_names, :pointer_names, :address_arrays,
-                  :address_parameters
+                  :address_parameters, :random_names, :assigned_parameters
       # An offset that is an integer here rather than when the kernel runs.
       # A literal is one; so is arithmetic over literals, which is the same
       # number written a way that says where it came from -- `w[-RADIUS-1]`
@@ -187,7 +310,18 @@ class CArray
       attr_reader :windows
       attr_reader :index_names, :array_names, :scalar_names, :c_function_names, :body,
                   :written_arrays, :array_ranks, :subscripts, :inner_ranges,
+                  :index_sources, :unbounded_indices,
                   :contracted_names
+      # The C arrays the body declares, as [scope, name, storage, shape].
+      # Nothing in the operand tables says a body has any, so this is how the
+      # generator learns it has a header to include and a mask to refuse.
+      attr_reader :local_array_declarations
+
+      # Whether any of them is one of the zeroed spellings, which is what
+      # `<string.h>` is included for.
+      def clears_a_local_array?
+        @clears_a_local_array
+      end
 
       # A kernel that mentions UNDEF is a masked kernel whatever its arrays
       # happen to carry: it asks about masks, or makes them.
@@ -217,6 +351,45 @@ class CArray
         allocate.send(:scan_free_names, source, node)
       end
 
+      # The names the block hands to a C function whole, and reads in no
+      # other way.
+      #
+      # Wanted before the analyzer runs, because what the caller does with
+      # the answer -- leaving those arrays out of the broadcast -- has to
+      # happen before it: the broadcast is what a shape that does not line up
+      # dies in, and an array handed over whole has no shape to line up.
+      #
+      # The parameters decide, not the spelling.  A bare array name in an
+      # argument position looks like an address pass and need not be one: in
+      # the whole-array spelling a bare name is a cell, so `twice.call(a)`
+      # against `double twice(double x)` walks `a` cell by cell.  Asking the
+      # declaration is not a second reading of the signature -- the CFunction
+      # parsed it once, and this asks the same object the same question the
+      # analyzer asks.
+      #
+      # A name used as a cell anywhere, subscripted or bare, is not here
+      # however else it is also used: an array that is both walked and handed
+      # over is walked, and lines up as it always did.
+      def self.address_array_names (source, node: nil, c_functions: {})
+        analyzer = allocate
+        block = node || analyzer.send(:parse_block, source)
+        analyzer.send(:scan_address_array_names, block.body, c_functions)
+      end
+
+      # The names the block makes an array of its own under.
+      #
+      # Read off the source rather than off a built analyzer, because the
+      # caller needs them before it has anything to build one with: in the
+      # whole-array spelling a name the block assigns may be an array outside,
+      # and whether to look this one up outside is exactly what this answers.
+      # The compatibility spellings count too, so that `CArray.zeros(4)` is
+      # refused by the reader that knows why rather than by a broadcast.
+      def self.local_array_names (source, node: nil)
+        analyzer = allocate
+        block = node || analyzer.send(:parse_block, source)
+        analyzer.send(:scan_local_array_names, block.body)
+      end
+
       # `rank` is given only for a block that takes no parameters and writes
       # `out[] = a[] + b[]`.  There the rank is a property of the arrays
       # rather than of the block, so it arrives from the caller and the loop
@@ -245,11 +418,16 @@ class CArray
       # number, and is not the same statement.
       def initialize (source, node: nil, array_names: [], c_functions: {}, rank: nil,
                       steps: nil, contract: false, result: nil, function: false,
-                      pointers: {}, map: false, cell_names: [],
+                      pointers: {}, pointer_lengths: {}, map: false,
+                      cell_names: [],
                       recursion: nil, windows: [], returns: true,
-                      free_indices: nil)
+                      free_indices: nil, randoms: {}, masked: false,
+                      declared_parameters: nil)
         @source = source
         @node = node
+        # `jit_call`'s: the parameter names its declaration gave, standing
+        # where a block's own would.
+        @declared_parameters = declared_parameters
         @array_names = array_names
         # Arrays with one cell and no axis to walk -- a CScalar.  There is no
         # index to write for one, which is the whole of what distinguishes it
@@ -264,6 +442,11 @@ class CArray
         # none, because a window has nowhere to write one.
         @windows = windows
         @c_functions = c_functions
+        # The generators the block closed over, by the name it reached each
+        # one by, and the made-up name of the state array that carries it.
+        # A draw is neither a captured function nor an array read, so it is
+        # kept apart from both.
+        @randoms = randoms
         @function = function
         # A function declared `void` ends in a statement like any other; one
         # that returns ends in the expression it returns.  Which it is comes
@@ -279,6 +462,9 @@ class CArray
         # read and write, false to read only (= const), nil for one that
         # points at nothing in particular and so cannot be reached at all.
         @pointers = pointers
+        # And how many cells a pointer's declaration said it points at, for
+        # the ones whose declarator carried a length: `double v[3]`.
+        @pointer_lengths = pointer_lengths
         # What the function being compiled is called, what it takes and what
         # it returns -- so its own body can call it.  C puts a declarator's
         # name in scope inside the body it heads, and this is that.  Nil for
@@ -295,9 +481,20 @@ class CArray
           reaches[name] = Array.new(rank.to_i) { [0, 0] }
         }
         @uses_undef = false
+        # Whether the kernel this body belongs to carries masks, which the
+        # caller settled from the operands before anything was read here.  A
+        # body reads the same either way; what it decides is what a local
+        # array is -- cells alone, or cells with a shadow byte beside each of
+        # them -- and so how much stack one takes and what may be done with
+        # it.  Always false for a function body, which has no cell to take a
+        # mask from and nowhere to put one.
+        @masked = masked
         @calls_for_effect = false
         @outer_names = []
         @inner_names = []
+        @inner_sources_seen = []
+        @inner_aliases = {}
+        @index_sources = {}
         # How many loops the statement being built stands inside.  `break`
         # needs a loop to leave and does not care which kind: an inner loop
         # brings an index and a `while` brings none, but both are loops in C
@@ -306,7 +503,9 @@ class CArray
         @inner_names_seen = []
         @array_ranks = {}
         @inner_ranges = {}
+        @unbounded_indices = []
         @subscripts = Hash.new { |hash, key| hash[key] = [] }
+        @write_subscripts = Hash.new { |hash, key| hash[key] = [] }
         @given_rank = rank
         @steps = steps
         @contract = contract
@@ -316,13 +515,32 @@ class CArray
         @free_names = []
         @index_names = []
         @local_names = []
+        # The arrays the body made, by name: [storage type, shape] for the
+        # declaration in sight.  Kept beside @local_names rather than in it,
+        # because the two are different things under one syntax and a name
+        # holds one or the other -- which is what lets each say so.
+        @local_array_names = []
+        @local_arrays = {}
+        # One entry per C array the body declares, as
+        # [scope, name, storage, shape], so that the room they take together
+        # can be counted once the body has been read.  Two sibling loops that
+        # each declare `w` are one entry: their blocks do not overlap, so
+        # neither do their frames.
+        @local_array_declarations = []
+        @clears_a_local_array = false
+        # The locals each scope holds, innermost last: the kernel's block --
+        # or a function's -- and one for every inner loop's block around the
+        # statement being built.  `while` and `if` make none, as in Ruby.
+        @scopes = [[]]
         @assigned_names = []
         @scalar_names = []
         @c_function_names = []
         @parameter_names = []
+        @assigned_parameters = []
         @pointer_names = []
         @address_arrays = []
         @address_parameters = {}
+        @random_names = []
         @read_offsets = Hash.new { |hash, key| hash[key] = [] }
         @written_arrays = []
         analyze
@@ -377,18 +595,29 @@ class CArray
       end
 
       # A write is addressed the way a read is: every axis either walks with an
-      # outer index, at whatever offset, or is pinned at a position known
-      # before the first cell.
+      # index the kernel is running -- an outer one or an inner one, at
+      # whatever offset -- or is pinned at a position known before the first
+      # cell.
       #
       # Two iterations may land on the same cell -- `box[0]` puts every one of
       # them there -- and that is not an ambiguity: the extent states the
       # order, so what the array holds afterwards is what the same Ruby loop
       # would leave in it.  An inner loop already rests on exactly that, an
       # accumulator being one cell written once per pass.
+      #
+      # An inner index is in that position and not a weaker one: its loop
+      # states its extent the way the kernel's own extents do, so the cell it
+      # reaches is as knowable as `i`'s and is bounds-checked with it.  What
+      # the write is for is a row of workspace per outer cell -- filling one
+      # and walking back down it is the shape a small dense solve has, and it
+      # was the reason to add an axis rather than split a body into kernels
+      # that each pay a call.  It was refused until it was noticed that
+      # `kk = k + 0` on the way in compiled it anyway, as a scatter: the rule
+      # was stopping the spelling rather than the thing.
       def walking_subscripts? (subscripts)
         subscripts.all? { |index, offset|
           if index
-            @outer_names.include?(index)
+            index_identifier_in_scope?(index)
           else
             !offset.is_a?(Node) || Analyzer.fixed_subscript?(offset)
           end
@@ -452,9 +681,89 @@ class CArray
         node.is_a?(Prism::CallNode) && node.receiver.nil? && node.name == :raise
       end
 
+      def scan_address_array_names (node, c_functions)
+        # Two passes rather than one, because the arguments of a call sit
+        # under an ArgumentsNode: pruning them out of a single walk would
+        # mean matching a grandchild, and the set is the clearer statement.
+        addressed = {}.compare_by_identity
+        handed = []
+        collect_address_arguments(node, c_functions, handed, addressed)
+        return [] if handed.empty?
+        as_cells = []
+        collect_cell_names(node, addressed, as_cells)
+        (handed.uniq - as_cells - scan_local_array_names(node))
+      end
+
+      # The names standing bare where a declaration wants a pointer at
+      # numbers, and the argument nodes they stand in.
+      def collect_address_arguments (node, c_functions, handed, addressed)
+        return unless node
+        return if raise_call?(node)
+        if node.is_a?(Prism::CallNode) &&
+           C_FUNCTION_CALL_NAMES.include?(node.name) &&
+           (function = captured_name(node.receiver)) &&
+           c_functions.key?(function)
+          parameters = c_functions.fetch(function).parameters
+          arguments = node.arguments ? node.arguments.arguments : []
+          arguments.each_with_index do |argument, position|
+            next unless parameters[position]&.indexable?
+            given = captured_name(argument)
+            next unless given
+            handed << given
+            addressed[argument] = true
+          end
+        end
+        node.compact_child_nodes.each { |child|
+          collect_address_arguments(child, c_functions, handed, addressed)
+        }
+      end
+
+      # Every other way a name is reached: subscripted, or bare where a bare
+      # name is a cell.  One of these takes a name back out of the answer.
+      def collect_cell_names (node, addressed, as_cells)
+        return unless node
+        return if raise_call?(node)
+        return if addressed[node]
+        if node.is_a?(Prism::CallNode) && node.name == :[] &&
+           (subscripted = captured_name(node.receiver))
+          as_cells << subscripted
+        end
+        if (bare = captured_name(node)) &&
+           !(node.is_a?(Prism::CallNode) &&
+             C_FUNCTION_CALL_NAMES.include?(node.name))
+          as_cells << bare
+        end
+        node.compact_child_nodes.each { |child|
+          collect_cell_names(child, addressed, as_cells)
+        }
+      end
+
+      def scan_local_array_names (node)
+        return [] unless node
+        names = []
+        if node.is_a?(Prism::LocalVariableWriteNode) &&
+           self.class.local_array_constructor?(node.value)
+          names << node.name
+        end
+        node.compact_child_nodes.each { |child|
+          names.concat(scan_local_array_names(child))
+        }
+        names.uniq
+      end
+
       def names_constants (node)
         return [] unless node
         return [] if raise_call?(node)
+        # The receiver of a constructor is part of a spelling rather than a
+        # name the block reached outside for: `CArray.double(9)` says what to
+        # declare, and the class in front of it is not a value to look up.
+        # Left in, it is looked up, found to be a Class, and refused for
+        # being one -- which says nothing about the line that was written.
+        if self.class.local_array_constructor?(node)
+          arguments = node.arguments ? node.arguments.arguments : []
+          return arguments.flat_map { |argument| names_constants(argument) } +
+                 names_constants(node.block)
+        end
         # `Foo::TABLE` names one thing, and `Foo` on its own names none of
         # it, so a path is read whole and not descended into.
         return [node.slice.to_sym] if node.is_a?(Prism::ConstantPathNode)
@@ -501,6 +810,15 @@ class CArray
           raise Unsupported.new("kernel body is empty")
         end
         @assigned_names = collect_assigned_names(block.body)
+        read_parameter_assignments(block.body) if @function
+        # A parameter the body assigns is a local from the top of the body
+        # on, starting at the value the call passed.  Bound here, before any
+        # statement is built, so every read of it -- the first included --
+        # is a read of that local.
+        entry = @assigned_parameters.map { |name|
+          @scalar_names << name unless @scalar_names.include?(name)
+          assign_local(name, CaptureRead.new(name), nil)
+        }
 
         # A contraction may end in a bare expression rather than an
         # assignment; that is the form that allocates its result and returns.
@@ -509,19 +827,30 @@ class CArray
         # A block that ends in an assignment still has that assignment's
         # value, which is what Ruby says it has -- so jit_map keeps the
         # statement and reads the cell back for the value.
-        map_assignment = @map && last.is_a?(Prism::LocalVariableWriteNode)
+        map_assignment = @map && (last.is_a?(Prism::LocalVariableWriteNode) ||
+                                  last.is_a?(Prism::LocalVariableOperatorWriteNode))
         returns_value = (@function && @returns) || (@map && !map_assignment) ||
                         (@contract &&
                          !(last.is_a?(Prism::CallNode) && last.name == :[]=))
         built = statements[0..-2].map { |node| build_statement(node) }
         if map_assignment
           built << build_statement(last)
+          # `w = CArray.double(4)` as the last line: the block's value in Ruby
+          # is the array, and a cell of the result has nowhere to put one.
+          if built.last.is_a?(LocalArrayDeclaration)
+            raise Unsupported.new(
+              "this block ends by making `#{built.last.name}`, so its value " \
+              "is an array and there is no cell for one to go in; end with " \
+              "the number you want -- a cell of it, or `sum(#{built.last.name})` " \
+              "and its kin",
+              last.location)
+          end
           @map_value = build_name_read(last.name, last.location)
         else
           built << (returns_value ? build(last) : build_statement(last))
           @map_value = built.last if @map
         end
-        @body = KernelBody.new(built)
+        @body = KernelBody.new(entry + built)
 
         return if @contract == :probe || @map == :probe
         return if @function
@@ -544,22 +873,52 @@ class CArray
         end
       end
 
-      # An array the kernel writes is written once per outer cell; reading it
-      # through an inner index would reach cells other outer iterations own,
-      # and no evaluation order settles that.
+      # An array the kernel writes at `a[i]` is written once per outer cell,
+      # and reading it at `a[j]` for an inner `j` would reach cells other
+      # outer iterations own -- an order no extent states.
+      #
+      # What decides that is the axis the outer indices pick the cell by, not
+      # the array.  `work[i, k] = ...` gives outer cell i a row of its own,
+      # and `work[i, k]`, `work[i, j]` or `work[i, position]` are that row
+      # being read back inside the same cell, in the order the body states.
+      # So a read carrying an inner index has to address every axis some
+      # write walks with an outer index with that same index -- at whatever
+      # offset, `work[i-1, k]` being the row before this one and a recurrence
+      # like any other displaced read.  Where it does, the inner index is
+      # roaming inside the cell the outer ones already picked, and whatever
+      # the writes do along that axis they do there too.
       def verify_written_arrays_are_not_read_through_inner_indices
         @written_arrays.each do |array|
+          writes = @write_subscripts[array]
           @subscripts[array].each do |per_axis|
-            per_axis.each do |index, _|
-              next unless @inner_names_seen.include?(index)
+            inner = per_axis.map(&:first).find { |index|
+              @inner_names_seen.include?(index)
+            }
+            spelled = @index_sources.fetch(inner, inner) if inner
+            next unless inner
+            per_axis.each_with_index do |(index, _), axis|
+              name = outer_name_written(writes, axis)
+              next if name.nil? || name == index
               raise Unsupported.new(
-                "`#{array}` is written by this kernel, so it cannot also be " \
-                "read through the inner index `#{index}`")
+                "`#{array}` is written on axis #{axis} through `#{name}`, " \
+                "so it cannot also be read through the inner index " \
+                "`#{spelled}`: a read that carries one addresses axis " \
+                "#{axis} through `#{name}` too, or it reaches cells another " \
+                "outer iteration owns")
             end
           end
         end
       end
 
+      # The outer index the writes walk one axis with, where they agree on
+      # one.  Writes that pin the axis or work its position out say nothing
+      # about which cell is whose, and so name nothing here.
+      def outer_name_written (writes, axis)
+        names = writes.map { |written| written[axis]&.first }
+                      .select { |name| @outer_names.include?(name) }.uniq
+        names.size == 1 ? names.first : nil
+      end
+
       # Turns `c[i,j] = a[i,k] * b[k,j]` into the loops it stands for.
       #
       # Which indices are summed is not the assignment's business: a repeated
@@ -593,6 +952,23 @@ class CArray
             "array of your own")
         end
 
+        # And one expression is all of it: a local assigned before the summand
+        # is a run of statements, which a contraction has no room for -- the
+        # same reason it takes no local array.  Said here, because what said
+        # it before was the type assignment, which walks the accumulator's
+        # zero -- taken from the summand, above the loop the local is
+        # assigned in -- and reported the local as read before it is assigned.
+        leading = statements[0..-2].grep(Assignment).map(&:name)
+        unless leading.empty?
+          names = leading.uniq.map { |name| "`#{name}`" }.join(" and ")
+          raise Unsupported.new(
+            "#{names} #{leading.uniq.size == 1 ? 'is' : 'are'} assigned " \
+            "before the summand, and a contraction is one expression: there " \
+            "is no run of statements to assign in. Write the value into the " \
+            "expression, or write the loop with jit_for",
+            statements.first.location)
+        end
+
         write = writes.first
         unless write
           # The returned form: the free indices, in the order the block named
@@ -664,6 +1040,7 @@ class CArray
       def classify_indices (statements, write)
         counts = Hash.new(0)
         subscripts_of(statements, write).each { |index, _| counts[index] += 1 }
+        refuse_a_gathered_index(statements, write)
 
         missing = @index_names - counts.keys
         unless missing.empty?
@@ -671,25 +1048,84 @@ class CArray
             "#{missing.map { |name| "`#{name}`" }.join(', ')} " \
             "#{missing.size == 1 ? 'names no axis' : 'name no axis'} here")
         end
-        # Naming the result's axes says which indices are free; it does not
-        # say what a repetition means, and a repetition still means a sum.  So
-        # a named index is free however often it appears -- twice is what a
-        # point number does, and `square[a,a]` is the diagonal rather than a
-        # trace -- while a parameter is summed by repeating, here as under the
-        # convention.  One that appears once is free and was not named, which
-        # is a sum along an axis and is not a contraction.
+        # Naming the result's axes says which indices are free, and says it
+        # of all of them: what is not named is summed, at however few
+        # positions it sits.  So a named index is free however often it
+        # appears -- twice is what a point number does, and `square[a,a]` is
+        # the diagonal rather than a trace -- and a parameter is summed
+        # whether it repeats or not, which is what lets `"ik->i"` be written.
+        #
+        # Where nothing is named the convention decides instead, and there a
+        # repetition is what makes a sum: an index at one position is free,
+        # because a list that would have said otherwise was not given.
         if @free_indices
-          parameters = @index_names - @free_indices
-          alone = parameters.select { |name| counts[name] == 1 }
-          unless alone.empty?
-            raise Unsupported.new(describe_a_lone_parameter(alone))
-          end
-          return [@free_indices, parameters]
+          return [@free_indices, @index_names - @free_indices]
         end
         [@index_names.select { |name| counts[name] == 1 },
          @index_names.select { |name| counts[name] > 1 }]
       end
 
+      # An index inside a computed subscript -- `m[i, idx[k]]` -- is read at a
+      # position, but not at a position of the array it stands in: it
+      # addresses an axis of `idx`.  A contraction is a count of positions,
+      # and this one cannot be counted either way.  Counting it makes
+      # `m[i, idx[k]] * v[k]` a sum over k, which is what the notation says,
+      # and makes `a[i, k] * w[idx[i]]` a sum over i, which is not what
+      # anybody writing a gather means.  Not counting it leaves the first one
+      # a free index and the answer an outer product -- a whole matrix where
+      # the reader asked for a vector, quietly.
+      #
+      # So it is refused, and the loop it means is written with jit_for,
+      # where the gather is the ordinary computed subscript it already is.
+      def refuse_a_gathered_index (statements, write)
+        summand = write.is_a?(ElementWrite) ? write.expression : write
+        found = []
+        # Inside a gathering subscript every index is one of these, however
+        # deep: `a[idx[jdx[k]]]` gathers twice and k is no more a position of
+        # `a` for it.
+        inside = lambda do |node|
+          return unless node.is_a?(Node)
+          subscript_indices(node).each do |index|
+            found << index if @index_names.include?(index)
+          end
+          gathered_subscripts(node).each { |offset| inside.call(offset) }
+          node.children.each { |child| inside.call(child) }
+        end
+        walk = lambda do |node|
+          return unless node.is_a?(Node)
+          gathered_subscripts(node).each { |offset| inside.call(offset) }
+          node.children.each { |child| walk.call(child) }
+        end
+        (statements[0..-2] + [summand]).each { |statement| walk.call(statement) }
+        return if found.empty?
+        names = found.uniq.map { |name| "`#{name}`" }.join(" and ")
+        raise Unsupported.new(
+          "#{names} #{found.uniq.size == 1 ? 'stands' : 'stand'} inside a " \
+          "subscript the kernel works out, where a contraction cannot count " \
+          "it: an index there addresses an axis of the array doing the " \
+          "gathering, not of the array being read, so whether it is summed " \
+          "or free is not something the notation says. Write the loop with " \
+          "jit_for",
+          summand.location)
+      end
+
+      # The indices a read names directly, as the symbols a subscript pair
+      # carries rather than as nodes.
+      def subscript_indices (node)
+        return [] unless node.is_a?(ElementRead) || node.is_a?(MaskTest)
+        node.subscripts.filter_map { |index, _| index }
+      end
+
+      # The subscript expressions a read works out, which are the ones an
+      # index can hide in.  A plain `a[i]` or `a[i-1]` carries its index in
+      # the pair itself and has none of these.
+      def gathered_subscripts (node)
+        return [] unless node.is_a?(ElementRead) || node.is_a?(MaskTest)
+        node.subscripts.filter_map { |index, offset|
+          offset if index.nil? && offset.is_a?(Node)
+        }
+      end
+
       # Every subscript on the right-hand side: the summand, and whatever the
       # locals before it read.
       def subscripts_of (statements, write)
@@ -706,22 +1142,6 @@ class CArray
         collected.reject { |index, _| index.nil? }
       end
 
-      # A parameter at one position only.  Nothing there stands in for a
-      # sigma, so summing it would be the argument list quietly meaning more
-      # than it says -- the same reason the convention refuses it.
-      def describe_a_lone_parameter (alone)
-        listed = alone.map { |name| "`#{name}`" }.join(", ")
-        named = (@free_indices + alone).map { |name| ":#{name}" }.join(", ")
-        "#{listed} #{alone.size == 1 ? 'appears' : 'appear'} once, so " \
-        "#{alone.size == 1 ? 'it is' : 'they are'} free rather than summed. " \
-        "A contraction sums the indices that repeat; name " \
-        "#{alone.size == 1 ? 'it' : 'them'} as " \
-        "#{alone.size == 1 ? 'an axis' : 'axes'} of the result " \
-        "(`CArray.jit_contract(#{named})`) to keep " \
-        "#{alone.size == 1 ? 'it' : 'them'}, or use sum(axis:) to sum along " \
-        "the axis"
-      end
-
       def describe_index_mismatch (written, free, summed)
         summed_on_left = written & summed
         unless summed_on_left.empty?
@@ -729,6 +1149,16 @@ class CArray
           # the result's axes, and the one that repeats is only the reason
           # the convention could not see it.
           named = written.map { |name| ":#{name}" }.join(", ")
+          if @free_indices
+            # A list was given, so what is summed is what the list left out.
+            # An axis of the left-hand side that is not in it is the list
+            # falling short of the result, not the index being a sum.
+            listed = summed_on_left.map { |name| "`#{name}`" }.join(", ")
+            return "#{listed} #{summed_on_left.size == 1 ? 'is an axis' : 'are axes'} " \
+                   "of the left-hand side and #{summed_on_left.size == 1 ? 'was' : 'were'} " \
+                   "not named. Naming the result's axes names all of them, and " \
+                   "what is left out is summed: `CArray.jit_contract(#{named})`"
+          end
           return "#{summed_on_left.map { |name| "`#{name}`" }.join(', ')} " \
                  "#{summed_on_left.size == 1 ? 'is repeated' : 'are repeated'} " \
                  "on the right, so #{summed_on_left.size == 1 ? 'it is' : 'they are'} " \
@@ -768,6 +1198,19 @@ class CArray
       # block's locals, and the indices -- an index called `contraction` would
       # have shared the identifier with the accumulator and the sum would have
       # come out zero, with nothing said.
+      # The identifier an inner index gets in the generated C: its own name
+      # the first time it is written, and a numbered one after that.  Every
+      # name the block has said is avoided, so nothing collides with a local
+      # or another index.
+      def free_index_name (index)
+        return index unless @inner_sources_seen.include?(index)
+        taken = @local_names + @index_names + @outer_names + @inner_names +
+                @inner_names_seen + @contracted_names
+        suffix = 2
+        suffix += 1 while taken.include?(:"#{index}__#{suffix}")
+        :"#{index}__#{suffix}"
+      end
+
       def free_local_name
         taken = @local_names + @index_names + @outer_names + @inner_names +
                 @contracted_names
@@ -785,16 +1228,72 @@ class CArray
         extract_block(result.value)
       end
 
+      # Every spelling that binds a local: `x = e`, the operator forms, which
+      # read the name and write it back, and a name on the left of a parallel
+      # assignment.  A name the block assigns is not a name it captures, and
+      # one that is an array outside is the array the whole-array spelling
+      # writes -- so an operator form left out here would have `out += a`
+      # reaching for a capture that is not there.
+      ASSIGNMENT_NODES = [Prism::LocalVariableWriteNode,
+                          Prism::LocalVariableOperatorWriteNode,
+                          Prism::LocalVariableOrWriteNode,
+                          Prism::LocalVariableAndWriteNode,
+                          Prism::LocalVariableTargetNode].freeze
+
       def collect_assigned_names (node)
         return [] unless node
         names = []
-        names << node.name if node.is_a?(Prism::LocalVariableWriteNode)
+        names << node.name if ASSIGNMENT_NODES.any? { |kind| node.is_a?(kind) }
         node.compact_child_nodes.each do |child|
           names.concat(collect_assigned_names(child))
         end
         names.uniq
       end
 
+      # A parameter the body assigns.  Left alone, the assignment was taken
+      # for a new local of the same name -- declared a second time in the C,
+      # which the C compiler refused, or read before it was assigned, which
+      # is not what it is.
+      #
+      # In a `jit_function` body it is what C makes of it: the parameter is
+      # the function's own copy of what it was called with, and a body may
+      # count it down or replace it.  So a number is kept, and bound as a
+      # local at the top of the body (see #analyze).  A pointer is not: the
+      # name is the array the body indexes, and a second array under it is
+      # nothing the body's arrays can be.
+      #
+      # For `jit_call` it is the leak in the block reading as a closure: the
+      # name is a local of the method around the call, and assigning it
+      # looks like writing that local, which a value passed by value cannot
+      # do.  An array parameter does come back, through its cells, so the
+      # two look alike and only one of them works.
+      def read_parameter_assignments (node)
+        return unless node
+        if ASSIGNMENT_NODES.any? { |kind| node.is_a?(kind) } &&
+           @parameter_names.include?(node.name)
+          name = node.name
+          if @declared_parameters
+            raise Unsupported.new(
+              "`#{name}` is a parameter of this `jit_call`, so assigning it " \
+              "looks like writing the local of that name -- and a parameter " \
+              "is passed by value, so nothing written here would reach it. " \
+              "An array's cells do come back, as in `#{name}[0] = ...`; for " \
+              "a number, give the body a local of its own name, or pass a " \
+              "one-cell array and write its cell",
+              node.location)
+          end
+          if @pointers.key?(name)
+            raise Unsupported.new(
+              "`#{name}` is a pointer parameter, and the body's arrays are " \
+              "the ones it was called with; write its cells, as in " \
+              "`#{name}[0] = ...`, rather than the name",
+              node.location)
+          end
+          @assigned_parameters << name unless @assigned_parameters.include?(name)
+        end
+        node.compact_child_nodes.each { |child| read_parameter_assignments(child) }
+      end
+
       # Accepts `->(i) { ... }`, `proc { |i| ... }` and `lambda { |i| ... }`.
       def extract_block (program)
         statements = program.statements.body
@@ -827,7 +1326,23 @@ class CArray
         end
 
         if @function
-          @parameter_names = requireds.map(&:name)
+          # A body written for `jit_call` takes no parameters: the names are
+          # in the declaration, where they also name the locals the call
+          # reads.  Written in both places they could disagree, so the block
+          # is refused for naming any.
+          if @declared_parameters
+            unless requireds.empty?
+              raise Unsupported.new(
+                "this body's parameters are the ones its declaration named " \
+                "-- #{@declared_parameters.map { |n| "`#{n}`" }.join(', ')} " \
+                "-- and the block names #{requireds.map { |p| "`#{p.name}`" }.join(', ')} " \
+                "again. Written in two places they could disagree; leave " \
+                "the block's off")
+            end
+            @parameter_names = @declared_parameters
+          else
+            @parameter_names = requireds.map(&:name)
+          end
           @index_names = []
           @outer_names = []
           return
@@ -955,31 +1470,34 @@ class CArray
             @uses_undef = true
             return MaskWrite.new(node.name, node.location)
           end
-          expression = build(node.value)
-          # In the whole-array spelling every name in the block is a cell, so
-          # an assignment to a name that is an array outside writes that
-          # array's cell -- the one the loop is on, the same cell every read
-          # in the block is at.  A name that is not an array is a local, as
-          # it is anywhere else.
-          if @whole_array && @array_names.include?(node.name)
-            return whole_array_write(node.name, expression, node.location)
+          # A constructor is read before the right-hand side is built, the way
+          # `out = UNDEF` above is: what it says is a declaration, not a value
+          # to compute and store.
+          if (made = read_local_array_constructor(node.value))
+            storage, shape, zeroed = made
+            return declare_local_array(node.name, storage, shape, zeroed,
+                                       node.location, node.depth)
           end
-          # An index is the loop's, not the block's.  Ruby reads `i = 2` as
-          # rebinding the parameter and leaves the loop alone; the C would
-          # assign to the counter, so the loop would walk somewhere else --
-          # to cells outside the array, given a value outside its extent.
-          # The two do not mean the same thing, so this is not compiled.
-          if index_in_scope?(node.name)
-            raise Unsupported.new(
-              "`#{node.name}` is a loop index, and assigning to it here would " \
-              "move the loop rather than the value: in Ruby the same line " \
-              "rebinds the parameter and the loop runs on. Use a local of " \
-              "another name",
-              node.location)
-          end
-          @local_names << node.name unless @local_names.include?(node.name)
-          Assignment.new(node.name, expression, node.location)
+          expression = build(node.value)
+          assign_local(node.name, expression, node.location, node.depth)
+        when Prism::LocalVariableOperatorWriteNode
+          build_operator_assignment(node)
+        when Prism::MultiWriteNode
+          build_parallel_assignment(node)
+        when Prism::IndexOperatorWriteNode
+          build_operator_element_write(node)
+        when Prism::LocalVariableOrWriteNode, Prism::LocalVariableAndWriteNode,
+             Prism::IndexOrWriteNode, Prism::IndexAndWriteNode
+          raise Unsupported.new(
+            "`#{node.is_a?(Prism::LocalVariableOrWriteNode) ||
+                node.is_a?(Prism::IndexOrWriteNode) ? '||=' : '&&='}` asks " \
+            "whether the value is already nil or false, which a number in a " \
+            "kernel never is; write the assignment out",
+            node.location)
         when Prism::CallNode
+          if (intrinsic = build_intrinsic_statement(node))
+            return intrinsic
+          end
           if node.receiver.nil? && node.name == :printf
             return build_print(node)
           end
@@ -989,7 +1507,8 @@ class CArray
           # pointed -- which is the whole reason C has statements that are
           # calls.  Everything else keeps the refusal below: a computation
           # standing where a statement stands is a line that does nothing.
-          if (call = recursive_call(node) || c_function_call(node))
+          if (call = recursive_call(node) || c_function_call(node) ||
+                     random_call(node))
             @calls_for_effect = true
             return CallStatement.new(call, node.location)
           end
@@ -1003,13 +1522,58 @@ class CArray
         when Prism::BreakNode
           build_loop_jump(node, LoopStop, "break")
         else
-          raise Unsupported.new(
-            "a kernel body holds assignments, `if`, `while`, `(a...b).each` " \
-            "and `n.times` only, got #{node_name(node)}",
-            node.location)
+          refuse_as_a_statement(node, statement_description(node))
         end
       end
 
+      # What a body may hold, said in one place: it was said in two, and they
+      # had already come apart -- one of them listing `step` and the other
+      # not.
+      def refuse_as_a_statement (node, description)
+        hint = STATEMENT_HINTS[node.class]
+        raise Unsupported.new(
+          "a kernel body holds assignments, `if`, `while`, `(a...b).each`, " \
+          "`n.times` and `a.step(b, s)` only, got #{description}" +
+          (hint ? " -- #{hint}" : ""),
+          node.location)
+      end
+
+      # A refusal names what was written rather than the node this compiler
+      # read it as: `Prism::UnlessNode` is not a thing anyone typed.
+      STATEMENT_DESCRIPTIONS = {
+        Prism::UnlessNode                 => "`unless`",
+        Prism::UntilNode                  => "`until`",
+        Prism::CaseNode                   => "`case`",
+        Prism::CaseMatchNode              => "`case ... in`",
+        Prism::ForNode                    => "`for`",
+        Prism::ReturnNode                 => "`return`",
+        Prism::BeginNode                  => "`begin`",
+        Prism::RescueModifierNode         => "`rescue`",
+        Prism::MultiWriteNode             => "a parallel assignment",
+        Prism::InstanceVariableWriteNode  => "an instance variable",
+        Prism::GlobalVariableWriteNode    => "a global variable",
+        Prism::ConstantWriteNode          => "an assignment to a constant",
+        Prism::DefNode                    => "a method definition",
+      }.freeze
+
+      STATEMENT_HINTS = {
+        Prism::UnlessNode  => "write it as `if` with the condition negated",
+        Prism::UntilNode   => "write it as `while` with the condition negated",
+        Prism::CaseNode    => "write the branches out with `if` and `elsif`",
+        Prism::ReturnNode  => "a body is one expression, and its value is " \
+                              "the last thing in it",
+        # A statement, and a supported one; what it has not got is a value.
+        # Ruby's is the array of what it wrote, and a cell holds a number.
+        Prism::MultiWriteNode =>
+                              "its value in Ruby is the array of what it " \
+                              "wrote, and a cell holds a number; end with " \
+                              "the one you want",
+      }.freeze
+
+      def statement_description (node)
+        STATEMENT_DESCRIPTIONS.fetch(node.class) { node_name(node) }
+      end
+
       # `next` skips the rest of this iteration, `break` leaves the loop.  Both
       # mean in the generated loop what they mean in the Ruby loop it replaces
       # -- with one exception: Ruby's `break` in the kernel block is not a
@@ -1061,7 +1625,7 @@ class CArray
             "Ruby; write the test at the top",
             node.location)
         end
-        condition = build(node.predicate)
+        condition = build_condition(node.predicate)
         @loop_depth += 1
         statements = statements_of(node.statements).map { |inner|
           build_statement(inner)
@@ -1116,7 +1680,12 @@ class CArray
       def build_inner_loop (node)
         counted = node.name == :times
         range = unwrap(node.receiver)
-        if !counted && !range.is_a?(Prism::RangeNode)
+        # Two spellings carry a stride, and they are Ruby's two: a range
+        # steps within the ends it already states, and an integer steps to
+        # one it is given.  Which is which is the receiver.
+        stepped = node.name == :step && !range.is_a?(Prism::RangeNode)
+        walked = node.name == :step && range.is_a?(Prism::RangeNode)
+        if !counted && !stepped && !range.is_a?(Prism::RangeNode)
           raise Unsupported.new(
             "an inner loop runs over a range, as in `(0...n).each { |j| ... }`",
             node.location)
@@ -1132,7 +1701,7 @@ class CArray
         if index_in_scope?(index)
           raise Unsupported.new("`#{index}` is already an index here", node.location)
         end
-        unless counted || (range.left && range.right)
+        unless counted || stepped || (range.left && range.right)
           raise Unsupported.new("an inner loop needs both ends of its range",
                                 node.location)
         end
@@ -1140,26 +1709,106 @@ class CArray
         # `n.times` is `(0...n).each`: the count is the exclusive end, and it
         # is built from the same vocabulary a range end is, so a literal and a
         # captured integer both serve.
+        #
+        # `from.step(to, s)` is the spelling an extent already says a stride
+        # or a downward sweep with, and it means here what it means there --
+        # `to` included, which is Ruby's own reading of it and the opposite of
+        # a `...` range's.  It is turned into an exclusive end at once, so
+        # everything below this line counts the way `each` does.
+        step = 1
         if counted
           from = IntegerLiteral.new(0, node.location)
           to = build(node.receiver)
+        elsif stepped
+          from = build(node.receiver)
+          arguments = node.arguments ? node.arguments.arguments : []
+          unless arguments.size == 2
+            raise Unsupported.new(
+              "an inner loop written with `step` gives it both the last " \
+              "index and the stride, as in `(n-1).step(0, -1) { |k| ... }`",
+              node.location)
+          end
+          step = inner_loop_step(arguments.last)
+          to = build(arguments.first)
+          to = BinaryOperation.new(step.positive? ? :+ : :-, to,
+                                   IntegerLiteral.new(1, node.location),
+                                   node.location)
         else
           from = build(range.left)
           to = build(range.right)
           to = BinaryOperation.new(:+, to, IntegerLiteral.new(1, node.location),
                                    node.location) unless range.exclude_end?
+          if walked
+            arguments = node.arguments ? node.arguments.arguments : []
+            unless arguments.size == 1
+              raise Unsupported.new(
+                "a range steps by one stride, as in `(0...n).step(2) " \
+                "{ |j| ... }`", node.location)
+            end
+            step = inner_loop_step(arguments.first)
+            if step.negative?
+              raise Unsupported.new(
+                "a range cannot step backwards, in Ruby either -- count " \
+                "down with `(n-1).step(0, -1) { |j| ... }`, which is the " \
+                "spelling an extent takes too",
+                node.location)
+            end
+          end
         end
 
+        # Two sibling loops may both be written `{ |k| ... }`, and each has
+        # a range of its own -- a forward sweep from 1 and the sweep back
+        # down from the far end are exactly that pair.  They are one name in
+        # the block and cannot be one variable here, because the reach of
+        # `a[k-1]` is checked against the loop it sits in.  So the second
+        # gets an identifier of its own, and the name in the block goes on
+        # meaning whichever loop it is inside.
+        internal = free_index_name(index)
         @inner_names << index
-        @inner_names_seen << index
-        @inner_ranges[index] = [from, to]
+        @inner_sources_seen << index
+        @inner_names_seen << internal
+        @inner_aliases[index] = internal
+        @index_sources[internal] = index
+        @inner_ranges[internal] = [from, to, step]
+        unless Analyzer.boundable_range?(from, @unbounded_indices) &&
+               Analyzer.boundable_range?(to, @unbounded_indices)
+          @unbounded_indices << internal
+        end
         @loop_depth += 1
+        @scopes.push([])
         statements = statements_of(node.block.body).map { |inner|
           build_statement(inner)
         }
+        @scopes.pop
         @loop_depth -= 1
         @inner_names.pop
-        InnerLoop.new(index, from, to, statements, node.location)
+        @inner_aliases.delete(index)
+        InnerLoop.new(internal, from, to, statements, node.location, step)
+      end
+
+      # The stride is read off the page rather than computed, because it is
+      # what says which way the loop runs and the C has to be written one way
+      # or the other before anything is known.  A captured integer would
+      # leave that open.
+      def inner_loop_step (node)
+        value = case node
+                when Prism::IntegerNode then node.value
+                when Prism::CallNode
+                  if node.name == :-@ && node.receiver.is_a?(Prism::IntegerNode)
+                    -node.receiver.value
+                  end
+                end
+        if value.nil?
+          raise Unsupported.new(
+            "an inner loop's stride says which way it runs, so it is an " \
+            "integer literal -- `step(0, -1)` for a downward sweep",
+            node.location)
+        end
+        if value.zero?
+          raise Unsupported.new("an inner loop's stride cannot be zero",
+                                node.location)
+        end
+        value
       end
 
       def unwrap (node)
@@ -1180,7 +1829,7 @@ class CArray
           else
             raise Unsupported.new("unsupported `if` continuation", node.location)
           end
-        Branch.new(build(node.predicate),
+        Branch.new(build_condition(node.predicate),
                    statements_of(node.statements).map { |inner|
                      build_statement(inner)
                    },
@@ -1192,8 +1841,1014 @@ class CArray
         node ? node.body : []
       end
 
+      # Handing a local array to a C function, with the declaration matched
+      # against what the block wrote.
+      #
+      # The length check is the one that matters, and it is not decoration: a
+      # compiled function does not check a subscript on a pointer parameter
+      # (unchecked by design -- the caller's business, as in C), and this
+      # array is on the stack of the block that made it.  A declaration that
+      # reads more cells than the array holds would walk over the frame, and
+      # the return address is in it.
+      def build_local_array_address (name, argument, parameter, c_function)
+        storage, shape = local_array_in_sight(name)
+        # The callee is handed a pointer to the cells, and the shadow beside
+        # them travels in no C declaration there is a spelling for here: a
+        # signature says what it points at, and "these cells, and a byte each
+        # saying whether they are there" is not one of the things it can say.
+        if @masked
+          raise Unsupported.new(
+            "`#{name}` is a local array of this kernel, and the kernel " \
+            "carries masks -- so `#{name}` carries one beside each of its " \
+            "cells, and there is no way to hand that to `#{c_function}`: a " \
+            "signature says what a pointer points at, and a mask travels in " \
+            "no C declaration. Copy the cells the function is to see into a " \
+            "captured array, or answer the mask in the kernel",
+            argument.location)
+        end
+        unless parameter&.pointer
+          raise Unsupported.new(
+            "`#{c_function}` takes #{parameter ? "`#{parameter.text}`" : 'a number'} " \
+            "there, and `#{name}` is an array; pass a cell of it, as in " \
+            "`#{name}[0]`",
+            argument.location)
+        end
+        unless parameter.indexable?
+          raise Unsupported.new(
+            "`#{c_function}` takes `#{parameter.text}` there, which points at " \
+            "nothing in particular, so there is no element type to hold " \
+            "`#{name}` to; declare what it points at",
+            argument.location)
+        end
+        wanted = CDeclaration::DATA_TYPES.fetch(parameter.element.fiddle).to_s
+        unless storage == wanted
+          raise Unsupported.new(
+            "`#{c_function}` takes `#{parameter.text}` there, which is a " \
+            "#{wanted} array, and `#{name}` is #{storage}; make it with " \
+            "`CArray.new(:#{wanted}, [#{shape.first}])` -- an element type is " \
+            "matched exactly here, as it is for a captured array",
+            argument.location)
+        end
+        # The cells over every axis, because that is what the callee is handed:
+        # a local array is packed row-major, so `double[3][4]` is the twelve
+        # cells `const double a[12]` asks for.
+        #
+        # A declaration that names a length can only be held to a shape that
+        # is numbers: the two are matched as the block is read, and a length
+        # the kernel works out is not there yet.  A pointer with no length is
+        # the C that says "however many you have", and takes one.
+        unless literal_shape?(shape)
+          if parameter.sized?
+            raise Unsupported.new(
+              "`#{c_function}` takes `#{parameter.text}` there, which reads " \
+              "#{parameter.array} cells, and the shape of `#{name}` is " \
+              "worked out when the kernel runs -- so the two cannot be " \
+              "matched here, and the function checks no subscript of its " \
+              "own. Declare the parameter without a length " \
+              "(`#{parameter.element.text} *`), which promises nothing about " \
+              "how many cells there are, or give `#{name}` a shape written " \
+              "out",
+              argument.location)
+          end
+          return LocalArrayAddress.new(name, storage, shape, argument.location)
+        end
+        cells = shape.inject(1, :*)
+        if parameter.sized? && cells < parameter.array
+          shaped = shape.size == 1 ? "" :
+                     " (#{shape.join(' x ')}, packed row-major)"
+          raise Unsupported.new(
+            "`#{c_function}` takes `#{parameter.text}` there, which reads " \
+            "#{parameter.array} cells, and `#{name}` has #{cells}#{shaped}. A " \
+            "local array is on this block's stack and the function does not " \
+            "check a subscript of its own, so the missing cells would be the " \
+            "frame; give `#{name}` at least #{parameter.array}",
+            argument.location)
+        end
+        LocalArrayAddress.new(name, storage, shape, argument.location)
+      end
+
+      # ---- the functions the compiler brings with it ----
+
+      # Written as bare calls, the way `random(rng: r)` is: names of this
+      # compiler's own rather than methods on an array, so that what each one
+      # means is settled here instead of promising CArray's method semantics
+      # -- `axis:`, masks skipped, an identity for an empty array, a CScalar
+      # or a number back, one type promoted to another.
+      #
+      # A bare name with no arguments is a capture (`sum = 0.0` beside
+      # `sum(w)` is a local and reads as one), and a name with a receiver is a
+      # call to whatever holds it (`sum.call(x)`), so neither collides.
+      INTRINSIC_VALUES = [:sum, :min, :max].freeze
+      INTRINSIC_STATEMENTS = [:sort].freeze
+      INTRINSIC_NAMES = (INTRINSIC_VALUES + INTRINSIC_STATEMENTS).freeze
+
+      # `sum(w)` / `min(w)` / `max(w)` in an expression, or nil where this
+      # call is not one of them.
+      def build_intrinsic_call (node)
+        return nil unless intrinsic_spelling?(node)
+        if INTRINSIC_STATEMENTS.include?(node.name)
+          raise Unsupported.new(
+            "`#{node.name}` rearranges the array and has no value to put " \
+            "anywhere; write it on a line of its own, then read the cells " \
+            "you want",
+            node.location)
+        end
+        return nil unless INTRINSIC_VALUES.include?(node.name)
+        name, storage, shape = intrinsic_array(node)
+        IntrinsicCall.new(node.name, name, storage, shape, node.location)
+      end
+
+      # `sort(w)` standing as a statement.
+      def build_intrinsic_statement (node)
+        return nil unless intrinsic_spelling?(node)
+        if INTRINSIC_VALUES.include?(node.name)
+          raise Unsupported.new(
+            "`#{node.name}` works out a value, and standing on a line of its " \
+            "own it puts that value nowhere; assign it, as in " \
+            "`total = #{node.name}(...)`",
+            node.location)
+        end
+        return nil unless INTRINSIC_STATEMENTS.include?(node.name)
+        name, storage, shape = intrinsic_array(node)
+        # Deliberately not `@calls_for_effect`: rearranging an array the body
+        # made leaves nothing outside the kernel, so a kernel whose only work
+        # is a `sort` has still put its work nowhere and is told so.
+        IntrinsicStatement.new(node.name, name, storage, shape, node.location)
+      end
+
+      def intrinsic_spelling? (node)
+        node.is_a?(Prism::CallNode) && node.receiver.nil? && node.block.nil? &&
+          INTRINSIC_NAMES.include?(node.name) && !node.arguments.nil?
+      end
+
+      # The one argument, which is a local array of one axis.
+      def intrinsic_array (node)
+        arguments = node.arguments ? node.arguments.arguments : []
+        unless arguments.size == 1
+          raise Unsupported.new(
+            "`#{node.name}` takes one local array, and #{arguments.size} " \
+            "#{arguments.size == 1 ? 'argument was' : 'arguments were'} " \
+            "given" +
+            (node.name == :min || node.name == :max ?
+               ". For the #{node.name} of two numbers write " \
+               "`x #{node.name == :min ? '<' : '>'} y ? x : y`, and to hold " \
+               "a value between two bounds write `x.clamp(lo, hi)`" : ""),
+            node.location)
+        end
+        argument = arguments.first
+        name = local_array_name(argument)
+        refuse_an_intrinsic_argument(node, argument) unless name
+        # What the four should do with a missing cell is not decided, and
+        # there is more than one defensible answer: skip it, gather it at the
+        # end the way `sort` gathers NaN, count it where a median is counted.
+        # So the array is refused rather than given a meaning here.
+        if @masked
+          raise Unsupported.new(
+            "`#{node.name}(#{name})` is over a local array of this kernel, " \
+            "and the kernel carries masks -- so `#{name}` carries one beside " \
+            "each of its cells, and what `#{node.name}` should do with a " \
+            "missing one is not decided: whether to pass over it, to gather " \
+            "it at the end as `sort` gathers NaN, or to count it where a " \
+            "median counts. Write the loop yourself, deciding it there",
+            node.location)
+        end
+        storage, shape = local_array_in_sight(name)
+        unless shape.size == 1
+          raise Unsupported.new(
+            "`#{name}` has #{shape.size} axes, and `#{node.name}` takes an " \
+            "array of one axis. A sweep over every cell would read well " \
+            "enough for `sum`, and `sort` over one has no obvious meaning at " \
+            "all, so the four keep one rule; walk the axes yourself, or copy " \
+            "the cells you want into an array of one axis",
+            node.location)
+        end
+        [name, storage, shape]
+      end
+
+      # What was passed instead, said in the terms it was written in.
+      def refuse_an_intrinsic_argument (node, argument)
+        passed = captured_name(argument)
+        if passed && @array_names.include?(passed)
+          raise Unsupported.new(
+            "`#{node.name}` takes a local array -- one this block made with " \
+            "`CArray.double(n)` or its kin -- and `#{passed}` is an array " \
+            "the block closed over. Walking all of it at every cell is a " \
+            "pass over the whole array per cell, which is not what the line " \
+            "looks like it costs; `#{passed}.#{node.name}` outside the " \
+            "kernel says what it costs, and a loop written out says it too",
+            node.location)
+        end
+        raise Unsupported.new(
+          "`#{node.name}` takes a local array -- one this block made with " \
+          "`CArray.double(n)` or its kin -- named on its own, and " \
+          "`#{argument.slice}` is not one",
+          node.location)
+      end
+
+      # ---- the arrays a body makes for itself ----
+
+      LOCAL_ARRAY_SUBSCRIPTS = [:[], :[]=].freeze
+
+      # A constructor stands on the right of an assignment and nowhere else.
+      # Everywhere else it is an array standing where a number goes -- in an
+      # argument, under a subscript, as an operand -- and there is no name for
+      # the C array to be declared under.
+      def refuse_a_constructor_in_an_expression (node)
+        return unless node
+        return unless self.class.local_array_constructor?(node)
+        raise Unsupported.new(
+          "`#{node.slice}` makes an array, and a constructor stands on the " \
+          "right of an assignment and nowhere else: write " \
+          "`w = #{node.slice}` on a line of its own, then reach `w` at a " \
+          "subscript",
+          node.location)
+      end
+
+      # `[storage type, shape, zeroed]` for a constructor, or nil where this
+      # call is not one.  Nil is the answer for everything else a body may
+      # write, so nothing outside this vocabulary is touched; once the answer
+      # is not nil the call is a constructor, and a spelling that cannot be
+      # taken is refused here rather than further along.
+      def read_local_array_constructor (node)
+        return nil unless self.class.local_array_constructor?(node)
+        refuse_a_local_array_in_this_spelling(node)
+        if node.block
+          raise Unsupported.new(
+            "`#{node.slice}` fills the array from a block, and a local " \
+            "array is either zero-filled or left as it stands; write the " \
+            "fill out as a loop over its cells",
+            node.location)
+        end
+        arguments = node.arguments ? node.arguments.arguments : []
+        if arguments.any? { |argument| argument.is_a?(Prism::KeywordHashNode) }
+          raise Unsupported.new(
+            "`#{node.slice}` passes a keyword, and a local array is the " \
+            "type and the shape only", node.location)
+        end
+        if node.receiver.is_a?(Prism::ConstantPathNode) &&
+           node.receiver.slice != "::CArray"
+          return refuse_a_type_class_constructor(node, arguments)
+        end
+        case node.name
+        when :new   then read_carray_new(node, arguments, true)
+        when :empty then read_carray_empty(node, arguments)
+        else             read_type_constructor(node, arguments)
+        end
+      end
+
+      # `CArray.double(9)` and the rest of the singleton methods CArray's own
+      # `Init` defines: the type is the name and the shape is the arguments.
+      def read_type_constructor (node, arguments)
+        if LOCAL_ARRAY_REFUSED_TYPES.include?(node.name)
+          raise Unsupported.new(
+            "`#{node.name}` holds #{LOCAL_ARRAY_REFUSED_TYPES_HOLD.fetch(node.name)} " \
+            "rather than numbers, and a kernel computes with numbers; a " \
+            "local array is one of " \
+            "#{LOCAL_ARRAY_TYPES.keys.take(13).map { |name| "`#{name}`" }.join(', ')}",
+            node.location)
+        end
+        if LOCAL_ARRAY_COMPATIBILITY_NAMES.include?(node.name)
+          return refuse_a_compatibility_constructor(node, arguments, nil)
+        end
+        storage = LOCAL_ARRAY_TYPES.fetch(node.name)
+        if arguments.empty?
+          raise Unsupported.new(
+            "`#{node.slice}` says no shape; a local array is written " \
+            "`CArray.#{node.name}(n)` with the length written out",
+            node.location)
+        end
+        [storage, read_local_array_shape(node, arguments), true]
+      end
+
+      # `CArray.new(:int64, [256])` -- `rb_ca_initialize`, whose
+      # `carray_safe_setup` is what fills the cells with zero.
+      def read_carray_new (node, arguments, zeroed)
+        unless arguments.size == 2
+          raise Unsupported.new(
+            "`CArray.#{node.name}` takes the type and the shape, as in " \
+            "`CArray.#{node.name}(:float64, [9])`", node.location)
+        end
+        [read_local_array_type(node, arguments.first),
+         read_local_array_shape(node, read_shape_arguments(node, arguments.last)),
+         zeroed]
+      end
+
+      # Two spellings share the name.  `CArray.empty(:float64, [9])` is
+      # carray's, and stands beside `CArray.new` with the fill left out;
+      # `CArray.empty(9)` is the compatibility layer's NumPy form, where the
+      # type is float64 by convention rather than by anything written down.
+      def read_carray_empty (node, arguments)
+        carray_form = arguments.size == 2 &&
+                      arguments.first.is_a?(Prism::SymbolNode) &&
+                      arguments.last.is_a?(Prism::ArrayNode)
+        return read_carray_new(node, arguments, false) if carray_form
+        refuse_a_compatibility_constructor(node, arguments, nil)
+      end
+
+      def read_shape_arguments (node, argument)
+        unless argument.is_a?(Prism::ArrayNode)
+          raise Unsupported.new(
+            "the shape `CArray.#{node.name}` takes is an Array, as in " \
+            "`CArray.#{node.name}(:float64, [9])`", node.location)
+        end
+        argument.elements
+      end
+
+      # The type is a Symbol written out.  One of CArray's constants would be
+      # a name looked up outside the block, and one kernel serves every value
+      # of a capture -- so a type that arrived that way would not be in the C
+      # at all.
+      def read_local_array_type (node, argument)
+        unless argument.is_a?(Prism::SymbolNode)
+          raise Unsupported.new(
+            "the type `CArray.#{node.name}` takes is a Symbol written out, " \
+            "as in `CArray.#{node.name}(:float64, [9])`; " \
+            "`#{argument.slice}` is looked up where the block was written, " \
+            "and one compiled kernel serves every value of that",
+            node.location)
+        end
+        name = argument.unescaped.to_sym
+        if LOCAL_ARRAY_REFUSED_TYPES.include?(name)
+          raise Unsupported.new(
+            "`:#{name}` holds #{LOCAL_ARRAY_REFUSED_TYPES_HOLD.fetch(name)} " \
+            "rather than numbers, and a kernel computes with numbers",
+            node.location)
+        end
+        LOCAL_ARRAY_TYPES.fetch(name) do
+          raise Unsupported.new(
+            "`#{argument.slice}` is not a type a local array holds; they are " \
+            "#{LOCAL_ARRAY_TYPES.keys.take(13).map { |n| "`:#{n}`" }.join(', ')}",
+            node.location)
+        end
+      end
+
+      # The shape, one entry an axis: an Integer where the block wrote a
+      # number, and a LocalArrayExtent where it wrote an expression over the
+      # integers it captured.  A number is what the C declares and what a
+      # subscript is checked against as the block is read; an expression is
+      # worked out once at the kernel's entry, and every check against it
+      # happens where the cell is reached.
+      def read_local_array_shape (node, arguments)
+        if arguments.empty?
+          raise Unsupported.new(
+            "`#{node.slice}` says no shape; a local array is written " \
+            "`CArray.#{node.name}(n)` with the length written out",
+            node.location)
+        end
+        arguments.map { |argument|
+          extent = literal_integer(argument)
+          next captured_extent(node, argument) unless extent
+          unless extent.positive?
+            raise Unsupported.new(
+              "a local array holds at least one cell, and `#{argument.slice}` " \
+              "asks for #{extent}", node.location)
+          end
+          extent
+        }
+      end
+
+      # A length the kernel works out at its entry, from the integers it
+      # captured.
+      #
+      # It may read nothing that varies from cell to cell: the array is one
+      # allocation for the whole pass, made before the first cell, so an
+      # extent over a loop index or an array's cell is a length that would
+      # have to change underneath it.  That is what is refused here, and the
+      # message says which of the two was written.
+      def captured_extent (node, argument)
+        built = build(argument)
+        varies = extent_varies_by_cell(built)
+        if varies
+          raise Unsupported.new(
+            "`#{argument.slice}` is the shape of a local array, and " \
+            "#{varies} -- the array is one allocation made before the first " \
+            "cell, so its length cannot change from cell to cell. Take the " \
+            "widest length the pass needs, or pass a captured array of " \
+            "workspace",
+            node.location)
+        end
+        LocalArrayExtent.new(argument.slice, built)
+      end
+
+      # What in an extent expression is not settled before the loop runs, in
+      # the words it was written in, or nil where everything in it is.
+      def extent_varies_by_cell (node)
+        case node
+        when IntegerLiteral, CaptureRead then nil
+        when UnaryMinus then extent_varies_by_cell(node.operand)
+        when BinaryOperation
+          unless [:+, :-, :*].include?(node.operator)
+            return "`#{node.operator}` is not one of `+`, `-` and `*`"
+          end
+          extent_varies_by_cell(node.left) || extent_varies_by_cell(node.right)
+        when IndexVariable then "`#{node.name}` is a loop index"
+        when LocalRead then "`#{node.name}` is worked out inside the block"
+        when ElementRead then "`#{node.array}` is a cell of an array"
+        when LocalArrayRead then "`#{node.name}` is a cell of an array"
+        else "it is not an integer expression over the captured integers"
+        end
+      end
+
+      # `CArray.zeros(4)`, `CArray.empty(4)`, `CArray.ones(4)`: the
+      # compatibility layer, which `data_type_extension.rb` opens by calling
+      # itself "Numo / NumPy-style" and "not the 'main' carray API".  The
+      # words inside a block are carray's own.
+      def refuse_a_compatibility_constructor (node, arguments, type)
+        storage = type || "float64"
+        length = arguments.empty? ? nil : literal_integer(arguments.first)
+        shape = length ? "[#{length}]" : "[n]"
+        raise Unsupported.new(
+          "`#{node.slice}` is CArray's Numo/NumPy compatibility layer, and " \
+          "a kernel body is written in carray's own words: " \
+          "`CArray.new(:#{storage}, #{shape})` for cells that start at zero, " \
+          "or `CArray.empty(:#{storage}, #{shape})` where every cell is " \
+          "written before it is read",
+          node.location)
+      end
+
+      # `CArray::Int64.empty(4)` and `CArray::Int64.zeros(4)`: the same layer
+      # reached through a type class, which is the Numo spelling of it.
+      def refuse_a_type_class_constructor (node, arguments)
+        tail = node.receiver.slice.split("::").last.to_s
+        type = LOCAL_ARRAY_TYPES[tail.downcase.to_sym]
+        refuse_a_compatibility_constructor(node, arguments, type)
+      end
+
+      # Which entry points take one, and which release takes the rest.  The
+      # shape of the check is the mode this analyzer was made in, because that
+      # is what says how the block is being read.
+      LOCAL_ARRAY_ELSEWHERE = {
+        :contract => ["a contraction's body", nil],
+      }.freeze
+
+      def refuse_a_local_array_in_this_spelling (node)
+        mode = if @contract          then :contract
+               end
+        return unless mode
+        where, when_ = LOCAL_ARRAY_ELSEWHERE.fetch(mode)
+        if mode == :contract
+          raise Unsupported.new(
+            "`#{node.slice}` makes a local array, and #{where} is one " \
+            "expression -- with, at most, an assignment into an array of its " \
+            "own -- so there is no run of statements for a workspace to be " \
+            "used by. Write the body as `CArray.jit_for`",
+            node.location)
+        end
+        raise Unsupported.new(
+          "`#{node.slice}` makes a local array, which #{where} takes in " \
+          "#{when_}; `CArray.jit_for` takes one now, and a captured array of " \
+          "workspace works here today",
+          node.location)
+      end
+
+      # The declaration itself.
+      def declare_local_array (name, storage, shape, zeroed, location, depth)
+        if index_in_scope?(name)
+          raise Unsupported.new(
+            "`#{name}` is a loop index, and the loop is what owns it; give " \
+            "the array a name of its own",
+            location)
+        end
+        if @local_names.include?(name) && local_in_sight?(name)
+          raise Unsupported.new(
+            "`#{name}` holds a number here, and a local array is not a " \
+            "number; the two cannot be one C variable, so give the array a " \
+            "name of its own",
+            location)
+        end
+        heap = heap_array?(storage, shape)
+        refuse_a_heap_array_in_a_body(name, storage, shape, location) if heap
+        @local_array_names << name unless @local_array_names.include?(name)
+        @local_arrays[name] = [storage, shape]
+        scope = [@scopes.size - 1 - depth, 0].max
+        @scopes[scope] << name unless @scopes[scope].include?(name)
+        entry = [scope, name, storage, shape, heap]
+        @local_array_declarations << entry unless @local_array_declarations.include?(entry)
+        @clears_a_local_array ||= zeroed
+        LocalArrayDeclaration.new(name, storage, shape, zeroed, location, scope,
+                                  heap)
+      end
+
+      # Where the array goes.  The stack while it is small enough to be a
+      # frame's business, and the heap otherwise -- which is a placement and
+      # not a refusal: nothing is turned away for its size any more.
+      #
+      # Three ways onto the heap: a length the kernel works out, an array
+      # larger than one frame should hold, and an array that fits on its own
+      # but not beside the ones this kernel already has.
+      def heap_array? (storage, shape)
+        return true unless literal_shape?(shape)
+        bytes = local_array_bytes(storage, shape)
+        return true if bytes > LOCAL_ARRAY_BYTE_LIMIT
+        bytes + stack_array_bytes > LOCAL_ARRAY_TOTAL_BYTE_LIMIT
+      end
+
+      def literal_shape? (shape)
+        shape.all? { |extent| extent.is_a?(Integer) }
+      end
+
+      # What the arrays declared so far take on the stack.  Two sibling
+      # loops that each declare `w` are one entry: their blocks do not
+      # overlap, so neither do their frames.
+      def stack_array_bytes
+        @local_array_declarations.sum { |_scope, _name, storage, shape, heap|
+          heap ? 0 : local_array_bytes(storage, shape)
+        }
+      end
+
+      # A compiled function's body is called once per cell, so an allocation
+      # in it would be one per cell -- and the body has no entry of its own
+      # outside the kernel's loop to make it at instead.
+      def refuse_a_heap_array_in_a_body (name, storage, shape, location)
+        return unless @function
+        reason =
+          if literal_shape?(shape)
+            "`#{name}` asks for " \
+            "#{local_array_bytes_phrase(storage, shape)}, which is past the " \
+            "#{LOCAL_ARRAY_BYTE_LIMIT} a frame here holds"
+          else
+            "the shape of `#{name}` is worked out when the kernel runs"
+          end
+        raise Unsupported.new(
+          "#{reason}, so `#{name}` would have to be allocated -- and a " \
+          "function's body is called once per cell, which would be one " \
+          "allocation per cell. Make the array in the kernel that calls " \
+          "this and pass it in, as a pointer parameter",
+          location)
+      end
+
+      # A shadow byte a cell where the kernel carries masks: it is on the
+      # same stack as the cells, so it is counted with them.
+      def local_array_bytes (storage, shape)
+        cells = shape.inject(1) { |product, extent| product * extent }
+        (LOCAL_ARRAY_STORAGE_BYTES.fetch(storage) + (@masked ? 1 : 0)) * cells
+      end
+
+      # How the refusal accounts for a size the block did not write out.
+      def local_array_bytes_phrase (storage, shape)
+        cells = shape.inject(1) { |product, extent| product * extent }
+        values = LOCAL_ARRAY_STORAGE_BYTES.fetch(storage) * cells
+        return "#{values} bytes of #{storage}" unless @masked
+        "#{values + cells} bytes -- #{values} of #{storage} and #{cells} of " \
+        "the mask beside it, a byte a cell, since this kernel carries masks"
+      end
+
+      # A name is in sight where some scope still standing holds it.  The
+      # scopes are pushed and popped with the inner loops' blocks, so a name
+      # an inner loop introduced is out of sight after it -- which is what
+      # Ruby says about it too.
+      def local_in_sight? (name)
+        @scopes.any? { |scope| scope.include?(name) }
+      end
+
+      # The name of the local array this receiver is, or nil.
+      #
+      # A name the body did make an array under, but in a block that has since
+      # closed, is neither: it says so rather than falling through to be
+      # refused for not being a captured array, which is not what happened.
+      def local_array_name (node)
+        name = case node
+               when Prism::LocalVariableReadNode
+                 node.name
+               when Prism::CallNode
+                 node.name if node.receiver.nil? && node.arguments.nil? &&
+                              node.block.nil?
+               end
+        return nil unless name && @local_array_names.include?(name)
+        unless local_in_sight?(name)
+          raise Unsupported.new(
+            "`#{name}` belongs to the loop block it was assigned in, and is " \
+            "not there after it; make the array before the loop",
+            node.location)
+        end
+        name
+      end
+
+      # `[storage, shape]` for the declaration in sight under this name.
+      def local_array_in_sight (name)
+        @local_arrays.fetch(name)
+      end
+
+      # A local array's subscripts.
+      #
+      # Not `read_subscripts`.  That one answers for the operand tables: it
+      # refuses an index where the block takes none, records the array's rank
+      # in a table shared with every other array, and hands a window its
+      # offsets instead.  A local array is in none of that -- its rank is its
+      # shape's, and its subscripts are written wherever the block stands.
+      # What the two share is only the two ways a position is checked.
+      def local_array_subscripts (name, shape, arguments, location)
+        unless arguments.size == shape.size
+          # A block may give one of its own arrays the name of the window it
+          # was handed.  Ruby reads that as rebinding the parameter, and so
+          # does this -- but then the window's own spelling stops working, and
+          # the axis count alone is a poor account of why.
+          if @windows.include?(name)
+            raise Unsupported.new(
+              "`#{name}` is the window this block was given, and the block " \
+              "also makes an array of its own under that name -- which " \
+              "rebinds it, here as in Ruby, so from that line on `#{name}` " \
+              "is the array and the window has no name left. " \
+              "`#{name}[#{Array.new(rank, 0).join(', ')}]` is the window's " \
+              "spelling and wants #{rank} #{rank == 1 ? 'offset' : 'offsets'}; " \
+              "give the array a name of its own",
+              location)
+          end
+          raise Unsupported.new(
+            "`#{name}` has #{shape.size == 1 ? 'one axis' : "#{shape.size} axes"}, " \
+            "so it takes #{shape.size == 1 ? 'one subscript' : "#{shape.size} subscripts"}, " \
+            "and #{arguments.size} #{arguments.size == 1 ? 'was' : 'were'} written",
+            location)
+        end
+        arguments.each_with_index.map { |argument, axis|
+          local_array_subscript(name, shape, axis, argument, location)
+        }
+      end
+
+      # How a message names the thing that is out of range.
+      #
+      # With one axis the whole subscript is the thing, and quoting it back is
+      # exactly right.  With more than one it is not: the block wrote
+      # `m[r, c]`, so quoting `m[c]` would be a spelling nobody typed, and an
+      # extent on its own ("a local array of 4 cells") is a poor account of a
+      # 3 x 4 one.  So the axis is named instead, and the shape with it.
+      def local_array_subject (name, shape, axis, argument)
+        if shape.size == 1
+          "`#{name}[#{argument.slice}]`"
+        else
+          "the subscript `#{argument.slice}` on axis #{axis} of `#{name}`, " \
+          "which is #{shape.join(' x ')},"
+        end
+      end
+
+      # What the cells of the axis in question are, said whole rather than as
+      # a fragment to glue on: the two ranks want different sentences and
+      # composing them produced "is outside and that axis has 4 cells".
+      def local_array_cells_phrase (shape, axis)
+        extent = shape[axis]
+        unless extent.is_a?(Integer)
+          length = "a length of `#{extent}`, which the kernel works out"
+          return shape.size == 1 ? "a local array of #{length}"
+                                 : "that axis's #{length}"
+        end
+        cells = "#{extent} #{extent == 1 ? 'cell' : 'cells'}"
+        run = extent == 1 ? "only cell is 0" : "cells are 0 to #{extent - 1}"
+        shape.size == 1 ? "a local array of #{cells}, whose #{run}"
+                        : "that axis's #{cells}, whose #{run}"
+      end
+
+      # (a) An index whose loop states its range in literals reaches a set of
+      # positions that is known now, so it is checked now and the C carries no
+      # test.  (b) Anything else is checked where the cell is reached.
+      #
+      # A literal position is (a) as well, its range being itself.
+      def local_array_subscript (name, shape, axis, argument, location)
+        extent = shape[axis]
+        # An axis whose length the kernel works out has nothing for (a) to
+        # compare against: a literal position included, since 3 is inside an
+        # array of 4 cells and outside one of 2.  So every position on such
+        # an axis is checked where the cell is reached.
+        return [nil, build(argument)] unless extent.is_a?(Integer)
+        if (index = index_name(argument)) && index_in_scope?(index)
+          settled = checked_index_subscript(name, shape, axis, index, 0,
+                                            argument, location)
+          return settled if settled
+        elsif argument.is_a?(Prism::CallNode) &&
+              [:+, :-].include?(argument.name) &&
+              (receiver = index_name(argument.receiver)) &&
+              index_in_scope?(receiver)
+          arguments = argument.arguments ? argument.arguments.arguments : []
+          if arguments.size == 1 && (offset = literal_integer(arguments.first))
+            offset = -offset if argument.name == :-
+            settled = checked_index_subscript(name, shape, axis, receiver,
+                                              offset, argument, location)
+            return settled if settled
+          end
+        end
+        if (position = literal_integer(argument))
+          unless (0...extent).cover?(position)
+            raise Unsupported.new(
+              "#{local_array_subject(name, shape, axis, argument)} is " \
+              "outside #{local_array_cells_phrase(shape, axis)}" +
+              (position.negative? ?
+                 ". A subscript here counts from the start, so CArray's " \
+                 "`#{name}[-1]` for the last cell is written " \
+                 "`#{name}[#{extent - 1}]`" : ""),
+              location)
+          end
+          return [nil, IntegerLiteral.new(position, location)]
+        end
+        [nil, build(argument)]
+      end
+
+      # The subscript settled as the block is read, or nil where it cannot be.
+      #
+      # Nil is not "allow it": it sends the axis to the check at the access,
+      # which is where every position this compiler cannot settle goes.  The
+      # two kinds it cannot settle are a loop whose bound is a captured
+      # integer and one whose range is written over another index -- in both
+      # the reach is not knowable until the kernel runs.  Returning the index
+      # unchecked would leave a write past the end of a stack array with
+      # nothing at all looking at it.
+      def checked_index_subscript (name, shape, axis, index, offset, argument,
+                                   location)
+        identifier = index_identifier(index)
+        return nil unless index_reach(identifier)
+        verify_index_reach(name, shape, axis, identifier, offset, argument,
+                           location)
+        [identifier, offset]
+      end
+
+      # The lowest and highest position an index takes, where its loop says so
+      # in literals; nil where it does not, or where the loop runs no passes
+      # at all and so reaches nothing.
+      #
+      # Computed rather than enumerated: `(0...10_000_000).each` states its
+      # range in literals too.
+      def index_reach (identifier)
+        range = @inner_ranges[identifier]
+        return nil unless range
+        from, to, step = range
+        return nil unless from.is_a?(IntegerLiteral) && to.is_a?(IntegerLiteral)
+        first = from.value
+        last_excluded = to.value
+        if step.positive?
+          return nil unless first < last_excluded
+          [first, first + ((last_excluded - 1 - first) / step) * step]
+        else
+          return nil unless first > last_excluded
+          stride = -step
+          [first - ((first - (last_excluded + 1)) / stride) * stride, first]
+        end
+      end
+
+      # This looks at the loop's range and not at what stands around the
+      # access, which is the character the captured arrays' own bounds check
+      # already has: an `if` around the line does not make the reach smaller,
+      # because the reach is the loop's.  Narrowing the loop's range is what
+      # makes it smaller.
+      def verify_index_reach (name, shape, axis, identifier, offset, argument,
+                              location)
+        extent = shape[axis]
+        reach = index_reach(identifier)
+        return unless reach
+        low = reach.first + offset
+        high = reach.last + offset
+        return if low >= 0 && high < extent
+        outside = low.negative? ? low : high
+        spelled = @index_sources.fetch(identifier, identifier)
+        raise Unsupported.new(
+          "#{local_array_subject(name, shape, axis, argument)} reaches cell " \
+          "#{outside} of #{local_array_cells_phrase(shape, axis)}: " \
+          "`#{spelled}` runs #{reach.first} to #{reach.last} here. Narrow " \
+          "the loop's range, or give `#{name}` more cells -- an `if` around " \
+          "the line does not narrow the reach, which is the loop's",
+          location)
+      end
+
+      # In the whole-array spelling every name in the block is a cell, so an
+      # assignment to a name that is an array outside writes that array's
+      # cell -- the one the loop is on, the same cell every read in the block
+      # is at.  A name that is not an array is a local, as it is anywhere
+      # else.
+      #
+      # `depth` is Prism's: how many scopes out the variable is.  Counted from
+      # the statement, it says which of the scopes here holds the local -- and
+      # one past the kernel's block is a name of the method around it, which
+      # the kernel holds as its own, as it always has.
+      def assign_local (name, expression, location, depth = 0)
+        if @whole_array && @array_names.include?(name)
+          return whole_array_write(name, expression, location)
+        end
+        # An index is the loop's, not the block's.  Ruby reads `i = 2` as
+        # rebinding the parameter and leaves the loop alone; the C would
+        # assign to the counter, so the loop would walk somewhere else -- to
+        # cells outside the array, given a value outside its extent.  The two
+        # do not mean the same thing, so this is not compiled.
+        if index_in_scope?(name)
+          raise Unsupported.new(
+            "`#{name}` is a loop index, and assigning to it here would " \
+            "move the loop rather than the value: in Ruby the same line " \
+            "rebinds the parameter and the loop runs on. Use a local of " \
+            "another name",
+            location)
+        end
+        if @local_array_names.include?(name)
+          if local_in_sight?(name)
+            raise Unsupported.new(
+              "`#{name}` is a local array here, and cannot hold a number; the " \
+              "two cannot be one C variable, so give the number a name of its " \
+              "own",
+              location)
+          end
+          # Out of sight, the array belonged to a block that has closed, and
+          # this line introduces a variable that merely shares its name.  The
+          # record goes, so a read below is read as the number it now is.
+          # The array itself stays counted: its C declaration is still in that
+          # block, and still on that block's stack.
+          @local_array_names.delete(name)
+          @local_arrays.delete(name)
+        end
+        @local_names << name unless @local_names.include?(name)
+        scope = [@scopes.size - 1 - depth, 0].max
+        @scopes[scope] << name unless @scopes[scope].include?(name)
+        Assignment.new(name, expression, location, scope)
+      end
+
+      # What a name on the left of a parallel assignment may not be, said the
+      # way it was written.  A cell may: `a[i], a[j] = a[j], a[i]` is the swap
+      # a sort is written with, and each half of it is the write `a[i] = ...`
+      # already was.
+      TARGET_DESCRIPTIONS = {
+        Prism::MultiTargetNode            => "a nested target",
+        Prism::SplatNode                  => "a splat",
+        Prism::ImplicitRestNode           => "a bare comma",
+        Prism::InstanceVariableTargetNode => "an instance variable",
+        Prism::GlobalVariableTargetNode   => "a global variable",
+        Prism::ClassVariableTargetNode    => "a class variable",
+        Prism::ConstantTargetNode         => "a constant",
+        Prism::ConstantPathTargetNode     => "a constant",
+        Prism::CallTargetNode             => "an attribute",
+      }.freeze
+
+      TARGET_HINTS = {
+        Prism::MultiTargetNode  => "it unpacks one value into several, and " \
+                                   "nothing in a kernel holds several; write " \
+                                   "the names out flat",
+        Prism::SplatNode        => "it takes however many values are left " \
+                                   "over, and how many there are is the one " \
+                                   "thing a C variable cannot be",
+        Prism::ImplicitRestNode => "it drops the rest of the values, and how " \
+                                   "many that is has to be written out here",
+      }.freeze
+
+      # `prev, cur = cur, prev + cur`, and the swap it is the general case of.
+      #
+      # Ruby settles every value on the right before it writes any of them,
+      # and so does this: each value is assigned to a name of its own first,
+      # and only then are the writes made.  The other way round, the line
+      # above would write `prev` and then read the new one back while working
+      # out `cur` -- which is the one thing the spelling exists to prevent,
+      # and why `jit_for` wanted it.  A recurrence advances by a parallel
+      # assignment in Ruby; until now it had to be unpicked by hand here, and
+      # the temporary a reader had to introduce is where the bug lives.
+      #
+      # The names are written even where nothing on the right reads what the
+      # left writes.  A rule that dropped them sometimes would be one a reader
+      # of the generated C had to know before they could tell what a line
+      # meant, and a C compiler drops a name assigned once and read once
+      # without being asked.
+      def build_parallel_assignment (node)
+        targets = parallel_targets(node)
+        values  = parallel_values(node, targets)
+        temporaries = values.map { |value|
+          assign_local(parallel_value_name, build(value), value.location)
+        }
+        writes = targets.each_with_index.map { |target, k|
+          value = build_name_read(temporaries[k].name, target.location)
+          if target.is_a?(Prism::LocalVariableTargetNode)
+            assign_local(target.name, value, target.location, target.depth)
+          else
+            indices = target.arguments ? target.arguments.arguments : []
+            element_write(target, indices, value, target.location)
+          end
+        }
+        ParallelAssignment.new(temporaries + writes, node.location)
+      end
+
+      def parallel_targets (node)
+        targets = node.lefts + (node.rest ? [node.rest] : []) + node.rights
+        targets.each do |target|
+          next if target.is_a?(Prism::LocalVariableTargetNode) ||
+                  target.is_a?(Prism::IndexTargetNode)
+          described = TARGET_DESCRIPTIONS[target.class]
+          hint = TARGET_HINTS[target.class]
+          raise Unsupported.new(
+            "a parallel assignment writes names and cells here -- " \
+            "`a, b = b, a`, `a[i], a[j] = a[j], a[i]` -- and this one writes " \
+            "#{described || node_name(target)}#{hint ? " -- #{hint}" : ""}",
+            target.location)
+        end
+        targets
+      end
+
+      # The values, told apart from the one value Ruby would spread.
+      #
+      # `a, b = b, a` writes its values out, and Prism hands them over as an
+      # array with no brackets around it.  Brackets are Ruby's other spelling
+      # -- `a, b = [b, a]` -- and it means something else: one value, taken
+      # apart across the names.  Nothing in a kernel is a value that can be
+      # taken apart, so the two are told apart here rather than quietly read
+      # as one.
+      def parallel_values (node, targets)
+        value = node.value
+        unless value.is_a?(Prism::ArrayNode) && value.opening_loc.nil?
+          raise Unsupported.new(
+            "a parallel assignment takes one value per name, written out on " \
+            "the right, as in `a, b = b, a`. Ruby takes a single value apart " \
+            "across the names, and a kernel computes numbers -- there is " \
+            "nothing here to take apart",
+            value.location)
+        end
+        if (splat = value.elements.find { |element|
+                      element.is_a?(Prism::SplatNode) })
+          raise Unsupported.new(
+            "`*` spreads a value across the names, and how many it comes to " \
+            "is the one thing a C variable cannot be; write the values out",
+            splat.location)
+        end
+        unless value.elements.size == targets.size
+          # Ruby has an answer for either way round, and neither is one a
+          # kernel can keep: the names it runs out of values for are nil, and
+          # a value it runs out of names for is dropped.
+          raise Unsupported.new(
+            "this writes #{count_of(targets.size, "name")} and has " \
+            "#{count_of(value.elements.size, "value")} for them. Ruby " \
+            "#{value.elements.size < targets.size ?
+                 "leaves the rest of the names nil, which is not a number a " \
+                 "local or a cell can hold" :
+                 "drops the values it has no name for, and a value computed " \
+                 "and dropped is a line that does nothing"}",
+            node.location)
+        end
+        value.elements
+      end
+
+      def count_of (n, noun)
+        "#{n} #{n == 1 ? noun : noun + "s"}"
+      end
+
+      # A name for a value on the right that no name in the block can be, and
+      # that no other statement uses.
+      #
+      # The block's own text settles the first half: a local, a capture, an
+      # index and an array all appear in it, so a name that appears nowhere
+      # in it is none of them.  An underscore is added until that holds,
+      # which keeps the same block reading the same way every time -- it has
+      # to, the generated C being part of the cache key.
+      #
+      # The second half is the counter.  Two parallel assignments sharing a
+      # name would be two statements sharing a C variable, and a variable
+      # live at the head of a loop is one the loop carries: a body that
+      # swapped Integers before the loop and Floats inside it was refused for
+      # changing the type of `value1` on the way round -- a name its author
+      # never wrote, about a value that is dead by the end of the line it is
+      # on.  A name of its own per statement cannot be carried anywhere.
+      def parallel_value_name
+        @parallel_value_prefix ||= begin
+          text = (@source || @node&.slice).to_s
+          prefix = "value"
+          prefix = "_" + prefix while text.include?(prefix)
+          prefix
+        end
+        @parallel_value_count = @parallel_value_count.to_i + 1
+        :"#{@parallel_value_prefix}#{@parallel_value_count}"
+      end
+
+      # `x += e` is `x = x + e`, and is read as exactly that: the name is
+      # read where Ruby reads it -- before the right-hand side, and by the
+      # same rule, so a name the block has not assigned yet says so rather
+      # than starting from whatever C left in the variable.
+      def build_operator_assignment (node)
+        operator = assignment_operator(node)
+        read = build_name_read(node.name, node.location)
+        expression = combined(operator, read, build(node.value), node.location)
+        assign_local(node.name, expression, node.location, node.depth)
+      end
+
+      # `a[i] += e` is `a[i] = a[i] + e`, cell for cell -- including under a
+      # mask, where the read is a read like any other and carries what it
+      # finds into what is written.
+      def build_operator_element_write (node)
+        operator = assignment_operator(node)
+        indices = node.arguments ? node.arguments.arguments : []
+        read = build_element_read(node, indices)
+        expression = combined(operator, read, build(node.value), node.location)
+        element_write(node, indices, expression, node.location)
+      end
+
+      # The operators an assignment may carry are the ones an expression may:
+      # `||=` and `&&=` are refused where they are read, being about nil and
+      # false rather than about arithmetic.
+      def assignment_operator (node)
+        operator = node.binary_operator
+        unless (ARITHMETIC_OPERATORS + BIT_OPERATORS + [:**]).include?(operator)
+          raise Unsupported.new(
+            "`#{operator}=` is not one of the operators a kernel computes " \
+            "with", node.location)
+        end
+        operator
+      end
+
+      def combined (operator, left, right, location)
+        return power_node(left, right, location) if operator == :**
+        BinaryOperation.new(operator, left, right, location)
+      end
+
       def build_element_write (node)
-        return build_inner_loop(node) if node.name == :each || node.name == :times
+        if node.name == :each || node.name == :times || node.name == :step
+          return build_inner_loop(node)
+        end
         unless node.name == :[]=
           # An expression standing alone in this spelling is a computation
           # nobody can see: there is no index to have written it against, and
@@ -1205,54 +2860,98 @@ class CArray
               "`CArray.jit_map`",
               node.location)
           end
-          raise Unsupported.new(
-            "a kernel body holds assignments, `if`, `while`, `(a...b).each` " \
-            "and `n.times` only, got a call to `#{node.name}`",
-            node.location)
+          if INNER_LOOP_SPELLINGS.include?(node.name)
+            raise Unsupported.new(
+              "an inner loop is written `(a...b).each`, `n.times` or " \
+              "`a.step(b, s)`, which is the spelling an extent takes a " \
+              "stride and a direction in -- `#{node.name}` is not one of " \
+              "them",
+              node.location)
+          end
+          refuse_as_a_statement(node, "a call to `#{node.name}`")
         end
-        if (pointer = pointer_subscript(node, write: true))
+        arguments = node.arguments ? node.arguments.arguments : []
+        element_write(node, arguments[0..-2], nil, node.location,
+                      value_node: arguments.last)
+      end
+
+      # The write itself, with the indices and the value already told apart:
+      # `a[i] = e` puts the value last among the arguments, while `a[i] += e`
+      # keeps it somewhere else, and everything from here down is the same
+      # for both.  `value_node` is passed where the value is still a Prism
+      # node, since `a[i] = UNDEF` is a mark rather than a value and is read
+      # off the node.
+      def element_write (node, indices, expression, location, value_node: nil)
+        if (pointer = pointer_subscript(node, write: true, indices: indices))
           name, index = pointer
-          arguments = node.arguments.arguments
-          return PointerWrite.new(name, index, build(arguments.last),
-                                  node.location)
+          return PointerWrite.new(name, index,
+                                  expression || build(value_node), location)
+        end
+        refuse_a_constructor_in_an_expression(node.receiver)
+        if (name = local_array_name(node.receiver))
+          storage, shape = local_array_in_sight(name)
+          if value_node && undef_constant?(value_node)
+            # A kernel that writes UNDEF anywhere carries masks by that
+            # alone, so this is a mark on the shadow beside the cell.  In a
+            # function body there is no shadow: a function is handed numbers
+            # and pointers, and a mask reaches neither.
+            unless @masked
+              raise Unsupported.new(
+                "`#{name}` is a local array in a compiled function's body, " \
+                "and nothing there carries masks -- a function is handed " \
+                "numbers and pointers, and a mask travels in neither. Keep " \
+                "a value that stands for missing, or mark the cell in the " \
+                "kernel that called this",
+                location)
+            end
+            @uses_undef = true
+            return LocalArrayMaskWrite.new(
+              name, storage, shape,
+              local_array_subscripts(name, shape, indices, location), location)
+          end
+          return LocalArrayWrite.new(
+            name, storage, shape,
+            local_array_subscripts(name, shape, indices, location),
+            expression || build(value_node), location)
         end
-        array = array_name(node.receiver, node.location)
-        arguments = node.arguments ? node.arguments.arguments : []
+        array = array_name(node.receiver, location)
         # `out[] = ...` was how a block that had to run as Ruby said "the
         # whole array", `[]=` being the only spelling Ruby has for it.  The
         # block is read rather than run, and every name in it is a cell, so
         # the assignment is Ruby's own: `out = ...`.
-        if @whole_array && arguments.size == 1
+        if @whole_array && indices.empty?
           raise Unsupported.new(
             "`#{array}[] = ...` writes the cell the loop is on, which is what " \
             "`#{array} = ...` says; the block is read rather than run, so the " \
             "assignment is an ordinary one",
-            node.location)
+            location)
         end
-        subscripts = read_subscripts(array, arguments[0..-2], node.location)
-        # A kernel writes a cell its own indices reach -- or one it works out,
-        # which is a scatter and is checked as it is reached rather than in
-        # advance.  What it may not do is write through an index that is not
-        # the loop's: an inner index addresses reads only.
+        subscripts = read_subscripts(array, indices, location)
+        # A kernel writes a cell one of its own indices reaches -- an outer
+        # one or an inner one -- or one it works out, which is a scatter and
+        # is checked as it is reached rather than in advance.  What it may not
+        # do is write through a name that addresses no cell at all.
         #
         # In a contraction the left-hand side names which indices are free and
         # which are summed over, so it is checked there instead.
         unless @contract || walking_subscripts?(subscripts) ||
                computed_subscripts?(subscripts)
           raise Unsupported.new(
-            "a kernel writes through its own indices, so `#{array}[...]` on " \
-            "the left of `=` is addressed by #{@outer_names.join(', ')}, by a " \
-            "position fixed before the loop runs -- or by a value the kernel " \
-            "works out, which is a scatter",
-            node.location)
+            "a kernel writes through the indices it is running, so " \
+            "`#{array}[...]` on the left of `=` is addressed by " \
+            "#{available_indices}, by a position fixed before the loop runs " \
+            "-- or by a value the kernel works out, which is a scatter",
+            location)
         end
         record_subscripts(array, subscripts)
+        record_write_subscripts(array, subscripts)
         @written_arrays << array unless @written_arrays.include?(array)
-        if undef_constant?(arguments.last)
+        if value_node && undef_constant?(value_node)
           @uses_undef = true
-          return MaskWrite.new(array, node.location)
+          return MaskWrite.new(array, location)
         end
-        ElementWrite.new(array, build(arguments.last), node.location, subscripts)
+        ElementWrite.new(array, expression || build(value_node), location,
+                         subscripts)
       end
 
       def build (node)
@@ -1301,8 +3000,19 @@ class CArray
           # closes over nothing.
           build_name_read(node.name, node.location)
         else
-          raise Unsupported.new("unsupported expression #{node_name(node)}",
-                                node.location)
+          # Named as it was written where there is a name for it, and with
+          # the same advice a statement in that position gets: `unless` in
+          # value position was "unsupported expression Unless", which is
+          # this compiler's reading of it rather than the reader's.
+          described = STATEMENT_DESCRIPTIONS[node.class]
+          hint = STATEMENT_HINTS[node.class]
+          raise Unsupported.new(
+            described ?
+              "a kernel computes its value from arithmetic, comparisons, " \
+              "cells and calls, and this one is #{described}" \
+              "#{hint ? " -- #{hint}" : ""}" :
+              "unsupported expression #{node_name(node)}",
+            node.location)
         end
       end
 
@@ -1314,8 +3024,31 @@ class CArray
       def build_name_read (name, location)
         axis = @outer_names.index(name)
         return IndexVariable.new(name, axis, location) if axis
-        return IndexVariable.new(name, nil, location) if @inner_names.include?(name)
+        if @inner_names.include?(name)
+          return IndexVariable.new(@inner_aliases.fetch(name, name), nil, location)
+        end
+        if @local_array_names.include?(name)
+          unless local_in_sight?(name)
+            raise Unsupported.new(
+              "`#{name}` belongs to the loop block it was assigned in, and is " \
+              "not there after it; make the array before the loop",
+              location)
+          end
+          raise Unsupported.new(
+            "`#{name}` is a local array; index it, as in `#{name}[0]`. An " \
+            "array has no value of its own in a kernel -- what the name " \
+            "stands for is its cells",
+            location)
+        end
         if @local_names.include?(name)
+          # A local of an inner loop's block that has closed is not in sight:
+          # Ruby reads the same name after the block as a method call.
+          unless @scopes.any? { |scope| scope.include?(name) }
+            raise Unsupported.new(
+              "`#{name}` belongs to the loop block it was assigned in, and is " \
+              "not there after it; give it a value before the loop",
+              location)
+          end
           return LocalRead.new(name, location)
         end
         if @cell_names.include?(name)
@@ -1347,6 +3080,42 @@ class CArray
         CaptureRead.new(name, location)
       end
 
+      # What `if`, `while` and `?:` read.  A pointer parameter named bare
+      # there is Ruby's truthiness -- nil is false and an array is true -- so
+      # `if grad` asks whether an address came, which is what NLopt's
+      # derivative-free methods leave out.  Only where a condition is read:
+      # anywhere else the bare name would be a value, and a pointer is not
+      # one.  `!`, `&&`, `||` and parentheses are looked through, since each
+      # of those reads its operands as conditions too.
+      def build_condition (node)
+        case node
+        when Prism::ParenthesesNode
+          inner = node.body ? node.body.body : []
+          return build_condition(inner.first) if inner.size == 1
+        when Prism::AndNode
+          return LogicalOperation.new(:"&&", build_condition(node.left),
+                                      build_condition(node.right), node.location)
+        when Prism::OrNode
+          return LogicalOperation.new(:"||", build_condition(node.left),
+                                      build_condition(node.right), node.location)
+        when Prism::CallNode
+          if node.name == :! && node.receiver && node.arguments.nil?
+            return LogicalNot.new(build_condition(node.receiver), node.location)
+          end
+        end
+        pointer_test(node, false, node.location) || build(node)
+      end
+
+      # A PointerTest when `receiver` names a pointer parameter, nil when it
+      # does not.  Asking is not reaching through, so a `void *` may be asked
+      # too: whether a slot was filled is a question about the slot.
+      def pointer_test (receiver, null, location)
+        name = captured_name(receiver)
+        return nil unless name && @pointers.key?(name)
+        return nil if @local_names.include?(name)
+        PointerTest.new(name, null, location)
+      end
+
       def build_conditional (node)
         unless node.subsequent
           raise Unsupported.new("`if` without `else` has no value for every cell",
@@ -1355,7 +3124,7 @@ class CArray
         unless node.subsequent.is_a?(Prism::ElseNode)
           raise Unsupported.new("`elsif` is not supported", node.location)
         end
-        Conditional.new(build(node.predicate),
+        Conditional.new(build_condition(node.predicate),
                         build_single(node.statements, node.location, "if"),
                         build_single(node.subsequent.statements, node.location, "else"),
                         node.location)
@@ -1380,9 +3149,29 @@ class CArray
         if node.receiver.nil? && node.arguments.nil? && node.block.nil?
           return build_name_read(node.name, node.location)
         end
+        if (intrinsic = build_intrinsic_call(node))
+          return intrinsic
+        end
+        refuse_a_constructor_in_an_expression(node)
+        # A method on a local array.  The operators are left alone so that
+        # `w + 1` is refused for reading the array bare, which is what it
+        # does; a named method is refused here, where the name can be said.
+        if (holder = local_array_name(node.receiver)) &&
+           !LOCAL_ARRAY_SUBSCRIPTS.include?(node.name) &&
+           !(ARITHMETIC_OPERATORS + COMPARISON_OPERATORS +
+             BIT_OPERATORS + [:**]).include?(node.name)
+          raise Unsupported.new(
+            "`#{holder}` is a local array, and `#{node.name}` is a method " \
+            "CArray answers outside a kernel; inside one an array is reached " \
+            "at a subscript. Write the loop out over `#{holder}[k]`",
+            node.location)
+        end
         if (recursive = recursive_call(node))
           return recursive
         end
+        if (draw = random_call(node))
+          return draw
+        end
         if (c_function = c_function_call(node))
           return c_function
         end
@@ -1421,6 +3210,42 @@ class CArray
         if node.name == :** && arguments.size == 1
           return build_power(node.receiver, arguments.first, node.location)
         end
+        if node.name == :clamp
+          unless arguments.size == 2
+            raise Unsupported.new(
+              "`clamp` takes the two bounds, as in `x.clamp(0.0, 1.0)`" +
+              (arguments.size == 1 ? " -- the range form is not in the subset" : ""),
+              node.location)
+          end
+          return Clamp.new(build(node.receiver), build(arguments.first),
+                           build(arguments.last), node.location)
+        end
+        if node.name == :nil? && arguments.empty? &&
+           (test = pointer_test(node.receiver, true, node.location))
+          return test
+        end
+        if [:==, :!=].include?(node.name) && arguments.size == 1
+          # `grad == nil` and `nil == grad`, which Ruby answers the way
+          # `grad.nil?` does and so may be written wherever that is.
+          receiver, other = node.receiver, arguments.first
+          receiver, other = other, receiver if receiver.is_a?(Prism::NilNode)
+          if other.is_a?(Prism::NilNode) &&
+             (test = pointer_test(receiver, node.name == :==, node.location))
+            return test
+          end
+        end
+        if arguments.empty? && NUMERIC_PREDICATES.include?(node.name)
+          return NumericPredicate.new(node.name, build(node.receiver),
+                                      node.location)
+        end
+        if arguments.empty? && node.name == :infinite?
+          raise Unsupported.new(
+            "`infinite?` answers nil, 1 or -1 in Ruby rather than true or " \
+            "false, and a kernel has no nil to answer with; ask " \
+            "`x.abs == Float::INFINITY`, or `x == Float::INFINITY` where " \
+            "the sign is the question",
+            node.location)
+        end
         if arguments.empty?
           if (function = postfix_math(node.name))
             return MathCall.new(function, [build(node.receiver)], node.location)
@@ -1507,11 +3332,26 @@ class CArray
             "only a cell can be compared with UNDEF, as in `a[i] == UNDEF`",
             location)
         end
+        arguments = receiver.arguments ? receiver.arguments.arguments : []
+        if (made = local_array_name(receiver.receiver))
+          storage, shape = local_array_in_sight(made)
+          unless @masked
+            raise Unsupported.new(
+              "`#{made}` is a local array in a compiled function's body, " \
+              "and nothing there carries masks -- a function is handed " \
+              "numbers and pointers, and a mask travels in neither, so " \
+              "there is no shadow beside these cells to ask about",
+              location)
+          end
+          @uses_undef = true
+          return LocalArrayMaskTest.new(
+            made, storage, shape,
+            local_array_subscripts(made, shape, arguments, location),
+            negated, location)
+        end
         array = array_name(receiver.receiver, location)
         array_for_test = array
-        subscripts = read_subscripts(array_for_test,
-                                     receiver.arguments ? receiver.arguments.arguments : [],
-                                     location)
+        subscripts = read_subscripts(array_for_test, arguments, location)
         # Recorded like any other read, because the cell still has to exist
         # and still has to have been settled before it is asked about.  What
         # it does not do is feed the value-mask propagation, which is decided
@@ -1525,7 +3365,7 @@ class CArray
       # does not.  A pointer declared const is refused on the left rather than
       # silently written through: the declaration is a promise to the caller,
       # not decoration.
-      def pointer_subscript (node, write: false)
+      def pointer_subscript (node, write: false, indices: nil)
         name = captured_name(node.receiver)
         return nil unless name && @pointers.key?(name)
         case @pointers.fetch(name)
@@ -1541,14 +3381,36 @@ class CArray
               "not write through it", node.location)
           end
         end
-        arguments = node.arguments ? node.arguments.arguments : []
-        arguments = arguments[0..-2] if write
+        arguments = indices
+        unless arguments
+          arguments = node.arguments ? node.arguments.arguments : []
+          arguments = arguments[0..-2] if write
+        end
         unless arguments.size == 1
           raise Unsupported.new(
             "`#{name}` is a pointer, so it takes one index", node.location)
         end
         @pointer_names << name unless @pointer_names.include?(name)
-        [name, build(arguments.first)]
+        index = build(arguments.first)
+        refuse_undeclared_cell(name, index, node.location)
+        [name, index]
+      end
+
+      # A subscript on a pointer is not checked when the function runs: that
+      # is C's bargain, and a computed one could only be checked there.  A
+      # literal needs no running to be read, though, and where the
+      # declaration said how many cells there are, one outside them is a
+      # write or a read past what the caller was held to -- the caller is
+      # checked for at least that many and no more.  C says nothing about
+      # `v[7]` against `double v[2]`; this says it as the body is read.
+      def refuse_undeclared_cell (name, index, location)
+        length = @pointer_lengths[name]
+        return unless length && index.is_a?(IntegerLiteral)
+        return if index.value >= 0 && index.value < length
+        raise Unsupported.new(
+          "`#{name}[#{index.value}]` is outside the #{length} " \
+          "#{length == 1 ? 'cell' : 'cells'} `#{name}` is declared with; " \
+          "a caller is held to that many and no more", location)
       end
 
       # `fact(n - 1)` inside the body of `double fact(double)`, and
@@ -1561,16 +3423,19 @@ class CArray
       def recursive_call (node)
         return nil unless @recursion
         name, parameters, result_type = @recursion
-        # `fact.call(n - 1)`, the spelling every other C function takes.  A
-        # bare `fact(n - 1)` would read better as C and is refused all the
-        # same: it is not Ruby, and the block has to stay runnable, since
-        # running it beside the compiled function is how the two are checked
-        # against each other.
+        # `fact.call(n - 1)`, the spelling every other C function takes,
+        # borrowed or written.  A bare `fact(n - 1)` reads better as C and is
+        # refused all the same, because a bare call is a spelling this
+        # compiler has taken for itself: `sum(w)` and `sort(w)` are its own
+        # functions, reached by no name the block wrote.  A function of yours
+        # is reached through the name that holds it -- which is also what
+        # makes a recursion read like a call to anything else.
         if node.receiver.nil? && node.name == name && node.arguments
           raise Unsupported.new(
             "`#{name}` calls itself the way any C function is called here, " \
-            "as `#{name}.call(...)` -- a bare `#{name}(...)` is not Ruby, and " \
-            "the block has to stay runnable",
+            "as `#{name}.call(...)` -- a bare `#{name}(...)` is how this " \
+            "compiler spells its own functions, such as `sum(w)`, and a " \
+            "function of yours is reached through the name that holds it",
             node.location)
         end
         return nil unless C_FUNCTION_CALL_NAMES.include?(node.name) &&
@@ -1590,6 +3455,111 @@ class CArray
         RecursiveCall.new(name, built, parameters, result_type, node.location)
       end
 
+      # `int64_t s[4]`, the parameter the generator's own C takes.  Held as a
+      # parsed declaration rather than described here, so that what the state
+      # array is checked against is the C the draw will actually be compiled
+      # into -- the same check `poly.call(x, coef)` gets, from the same code.
+      # Parsed on first use: the declaration parser is in c_function.rb,
+      # which is required after this file.
+      def self.random_state_parameter
+        @random_state_parameter ||=
+          CDeclaration.parse("double draw(int64_t state[4])").last.first
+      end
+
+      # `r.rand` and `r.bits` -- a draw written as a method of the generator,
+      # which is how Ruby writes one.  `#rand` and `#bits` do these outside a
+      # kernel, and the same names inside it mean the same two things.
+      RANDOM_DRAW_METHODS =
+        { :random => :random, :randomn => :randomn, :bits => :bits }.freeze
+
+      # `random(rng: r)` -- the same draw as `r.rand`, written as the array
+      # language writes it.  `a.random!(rng: r)` fills an array from a
+      # generator, and this is that sentence about one cell, so a reader
+      # moving between the two reads one word rather than matching two up.
+      #
+      # It is the only keyword argument in the subset and the only bare name
+      # in it that Ruby does not have; both are paid for that.
+      RANDOM_KEYWORD_NAMES =
+        { :random => :random, :randomn => :randomn }.freeze
+      RANDOM_DRAW_KEYWORD = "rng"
+
+      # Returns the node for a draw from a captured CArray::Rng, or nil when
+      # this is not one.
+      def random_call (node)
+        if node.receiver.nil? && (kind = RANDOM_KEYWORD_NAMES[node.name])
+          return build_random_draw(random_generator_name(node), kind, node)
+        end
+        name = captured_name(node.receiver)
+        return nil unless name && @randoms.key?(name)
+        kind = RANDOM_DRAW_METHODS[node.name]
+        refuse_a_generator_call(name, node) unless kind
+        unless (node.arguments ? node.arguments.arguments : []).empty?
+          bounded = node.name == :random ?
+            ". `CArray#random!` takes a range for a whole array; a kernel " \
+            "has no bounded draw, so scale the one you get" : ""
+          raise Unsupported.new(
+            "`#{name}.#{node.name}` in a kernel is one draw and takes no " \
+            "arguments#{bounded}",
+            node.location)
+        end
+        build_random_draw(name, kind, node)
+      end
+
+      def build_random_draw (name, kind, node)
+        state = @randoms.fetch(name)
+        @random_names << name unless @random_names.include?(name)
+        # The state travels the way any array handed to a C function whole
+        # does: by address, in the `data` buffer, copied back after the call.
+        # That copy-back is what leaves the generator advanced.
+        @address_arrays << state unless @address_arrays.include?(state)
+        (@address_parameters[state] ||= []) << self.class.random_state_parameter
+        RandomDraw.new(name, state, kind, node.location)
+      end
+
+      # Everything else reached on a generator.  There are three spellings
+      # and no fourth, so the message lists them rather than saying only that
+      # this one is not among them.
+      def refuse_a_generator_call (name, node)
+        raise Unsupported.new(
+          "`#{name}` is a generator, and `#{name}.#{node.name}` is not a way " \
+          "to draw from one. A kernel has `#{name}.random` for a double in " \
+          "[0.0, 1.0), `#{name}.randomn` for a standard normal, " \
+          "`#{name}.bits` for the raw word, and `random(rng: #{name})` or " \
+          "`randomn(rng: #{name})` for the first two written as " \
+          "`CArray#random!` writes them",
+          node.location)
+      end
+
+      # Which generator `random` was pointed at, or a refusal saying how to
+      # point it at one.  Nothing else is accepted in the parentheses: a
+      # range, a bound, a data type are all things `CArray#random!` takes and
+      # none of them has an answer for one cell.
+      def random_generator_name (node)
+        arguments = node.arguments ? node.arguments.arguments : []
+        keywords = arguments.last if arguments.last.is_a?(Prism::KeywordHashNode)
+        pairs = keywords ? keywords.elements : []
+        unless arguments.size == 1 && keywords && pairs.size == 1 &&
+               pairs.first.is_a?(Prism::AssocNode) &&
+               pairs.first.key.is_a?(Prism::SymbolNode) &&
+               pairs.first.key.unescaped == RANDOM_DRAW_KEYWORD
+          raise Unsupported.new(
+            "`#{node.name}` in a kernel draws one number from a generator " \
+            "and takes `rng:` and nothing else -- `#{node.name}(rng: r)`, " \
+            "where `r` is a `CArray::Rng` the block closed over",
+            node.location)
+        end
+        name = captured_name(pairs.first.value)
+        unless name && @randoms.key?(name)
+          reached = name ? "`#{name}`" : "what was written there"
+          raise Unsupported.new(
+            "`rng:` takes a `CArray::Rng` the block closed over, and " \
+            "#{reached} is not one. A Ruby `Random` cannot be reached from a " \
+            "kernel at all; `CArray::Rng.new` makes one that can",
+            pairs.first.value.location)
+        end
+        name
+      end
+
       # Returns the node for a call on a captured C function, or nil when this
       # is not one.
       def c_function_call (node)
@@ -1600,7 +3570,8 @@ class CArray
         arguments = node.arguments ? node.arguments.arguments : []
         unless arguments.size == c_function.arity
           raise Unsupported.new(
-            "`#{name}` is `#{c_function}`, so it takes #{c_function.arity} " \
+            "`#{name}` is `#{c_function.declaration_as(name)}`, so it takes " \
+            "#{c_function.arity} " \
             "#{c_function.arity == 1 ? 'argument' : 'arguments'}; " \
             "#{arguments.size} #{arguments.size == 1 ? 'was' : 'were'} given",
             node.location)
@@ -1618,6 +3589,16 @@ class CArray
       # name means a cell in one argument position and the whole array in
       # another -- `poly.call(x[i], coef)` says both.
       def build_c_function_argument (argument, parameter, c_function)
+        # A local array decays to the pointer the callee wants, as it does in
+        # C -- the name its declaration was written under is already the
+        # address.  What the declaration says about it is matched here, as the
+        # block is read, because both halves are written in the block: the
+        # element type is the constructor and the length is a literal.  A
+        # captured array is matched at the call instead (`address_buffer`),
+        # neither being knowable until there is an array.
+        if (name = local_array_name(argument))
+          return build_local_array_address(name, argument, parameter, c_function)
+        end
         # Inside a function, one of its own pointer parameters is already the
         # address the callee wants, and handing it on is what C does -- for a
         # `void *` slot as much as for a run of numbers, since neither is
@@ -1670,12 +3651,24 @@ class CArray
         ElementWrite.new(name, expression, location, subscripts)
       end
 
-      def build_element_read (node)
-        if (pointer = pointer_subscript(node))
+      # `indices` is given where the node is not a plain `a[i]` -- `a[i] += e`
+      # carries its indices and its value in different places, and the read
+      # it stands for is the same read either way.
+      def build_element_read (node, indices = nil)
+        if (pointer = pointer_subscript(node, indices: indices))
           return PointerRead.new(pointer.first, pointer.last, node.location)
         end
+        refuse_a_constructor_in_an_expression(node.receiver)
+        if (name = local_array_name(node.receiver))
+          storage, shape = local_array_in_sight(name)
+          arguments = indices || (node.arguments ? node.arguments.arguments : [])
+          return LocalArrayRead.new(
+            name, storage, shape,
+            local_array_subscripts(name, shape, arguments, node.location),
+            node.location)
+        end
         array = array_name(node.receiver, node.location)
-        arguments = node.arguments ? node.arguments.arguments : []
+        arguments = indices || (node.arguments ? node.arguments.arguments : [])
         subscripts = read_subscripts(array, arguments, node.location)
         record_subscripts(array, subscripts)
         ElementRead.new(array, subscripts, node.location)
@@ -1685,6 +3678,15 @@ class CArray
         @subscripts[array] << subscripts unless @subscripts[array].include?(subscripts)
       end
 
+      # Kept apart from the reads because the two are asked different
+      # questions: every use of an array decides the box a view is
+      # transferred in, while only the writes say which axes the kernel owns
+      # a cell of.
+      def record_write_subscripts (array, subscripts)
+        list = @write_subscripts[array]
+        list << subscripts unless list.include?(subscripts)
+      end
+
       def array_name (receiver, location)
         name = captured_name(receiver)
         unless name && @array_names.include?(name)
@@ -1769,9 +3771,13 @@ class CArray
       # in scope, so that the offset is a compile-time constant.
       def read_subscript (node, location)
         name = index_name(node)
-        return [name, 0] if name && index_in_scope?(name)
+        if name && index_in_scope?(name)
+          return [nil, pinned_subscript(node)] if unbounded_index?(name)
+          return [index_identifier(name), 0]
+        end
         if node.is_a?(Prism::CallNode) && [:+, :-].include?(node.name) &&
            (receiver = index_name(node.receiver)) && index_in_scope?(receiver)
+          return [nil, pinned_subscript(node)] if unbounded_index?(receiver)
           return walked_subscript(node)
         end
         # Anything else pins the axis at a position the loop does not walk:
@@ -1785,6 +3791,30 @@ class CArray
         build(node)
       end
 
+      # An inner index whose range reads a local or a cell.  Its range is not
+      # known until the loop is reached, so a subscript it walks cannot be
+      # checked before the kernel runs; it is checked at each access instead,
+      # as `a[b[i]]` is.
+      def unbounded_index? (name)
+        @unbounded_indices.include?(index_identifier(name))
+      end
+
+      # Whether an inner loop's range can be worked out before the kernel
+      # runs: literals, captured integers, the extents, and indices whose own
+      # range can, under `+`, `-` and `*`.
+      def self.boundable_range? (node, unbounded)
+        case node
+        when IntegerLiteral, CaptureRead, BoundsValue then true
+        when IndexVariable then !unbounded.include?(node.name)
+        when UnaryMinus    then boundable_range?(node.operand, unbounded)
+        when BinaryOperation
+          [:+, :-, :*].include?(node.operator) &&
+            boundable_range?(node.left, unbounded) &&
+            boundable_range?(node.right, unbounded)
+        else false
+        end
+      end
+
       # The one cell a CScalar has: position zero on its one axis, which is a
       # pinned subscript like any other and is checked like one.
       def cell_subscripts (array, location)
@@ -1840,10 +3870,39 @@ class CArray
             raise Unsupported.new("write the offset as `j - c` with c >= 0",
                                   node.location)
           end
-          return [receiver.name, node.name == :+ ? constant : -constant]
+          return [index_identifier(receiver.name),
+                  node.name == :+ ? constant : -constant]
         end
         offset = pinned_subscript(argument)
-        [receiver.name, node.name == :+ ? offset : UnaryMinus.new(offset)]
+        refuse_an_index_in_the_offset(node, receiver.name, offset)
+        [index_identifier(receiver.name),
+         node.name == :+ ? offset : UnaryMinus.new(offset)]
+      end
+
+      # `a[i + r]`, where `r` is an inner loop's index: the subscript walks
+      # with `i`, and an offset is worked out once per call, before any cell,
+      # which an index cannot be.  Left to the call, it was refused there
+      # for a reason about an inner loop's range -- true of the code that
+      # happened to read it, and nothing to do with what was written.  The
+      # same sum put in a local first is a subscript the kernel works out
+      # and checks at the cell, which is what the message points to.
+      def refuse_an_index_in_the_offset (node, walker, offset)
+        others = []
+        visit = lambda { |item|
+          next unless item.is_a?(Node)
+          others << item.name if item.is_a?(IndexVariable)
+          item.children.each(&visit)
+        }
+        visit.call(offset)
+        return if others.empty?
+        names = others.uniq.map { |name| "`#{name}`" }.join(" and ")
+        raise Unsupported.new(
+          "`#{node.slice}` walks with `#{walker}` and is offset by #{names}, " \
+          "an index as well; an offset is worked out once per call, from " \
+          "literals and captured integers -- put the sum in a local first " \
+          "(`k = #{node.slice}`, then `[k]`) and it is worked out and " \
+          "checked at each cell",
+          node.location)
       end
 
       # An index the block names as a parameter reads as a local variable.
@@ -1860,6 +3919,19 @@ class CArray
         end
       end
 
+      # An index as this compiler knows it: the name the block wrote, unless
+      # that name belongs to a second loop of the same name, which has an
+      # identifier of its own.
+      def index_identifier (name)
+        @inner_aliases.fetch(name, name)
+      end
+
+      # The same question asked of an identifier a subscript carries, which
+      # for a second loop of the same name is not the name the block wrote.
+      def index_identifier_in_scope? (name)
+        @outer_names.include?(name) || @inner_aliases.value?(name)
+      end
+
       def index_in_scope? (name)
         @outer_names.include?(name) || @inner_names.include?(name)
       end
@@ -1930,8 +4002,10 @@ class CArray
       # A non-negative literal exponent can still be squared out; anything
       # else has to be asked for in floating point.
       def build_power (receiver, exponent, location)
-        base = build(receiver)
-        power = build(exponent)
+        power_node(build(receiver), build(exponent), location)
+      end
+
+      def power_node (base, power, location)
         if power.is_a?(IntegerLiteral) && power.value < 0
           raise Unsupported.new(
             "a negative exponent gives a Rational in Ruby; write `1.0 / x ** n`",
@@ -1943,8 +4017,12 @@ class CArray
       def build_math_call (node)
         function = MATH_FUNCTIONS[node.name]
         unless function
-          raise Unsupported.new("Math.#{node.name} has no math.h counterpart",
-                                node.location)
+          if (reason = REFUSED_MATH[node.name])
+            raise Unsupported.new("Math.#{node.name} is not compiled: " \
+                                  "#{reason}", node.location)
+          end
+          raise Unsupported.new(
+            "Math.#{node.name} is not a name this compiles", node.location)
         end
         arguments = node.arguments ? node.arguments.arguments : []
         expected = [:atan2, :hypot].include?(node.name) ? 2 : 1