carray-jit 0.1.2 → 0.1.4

data/lib/carray/jit/type_assignment.rb

@@ -115,12 +115,16 @@ class CArray
       # every one of these answers false for it, so a guard written as "refuse
       # unless this is a number" refuses it rather than letting it through.
       def self.integer? (type)  = KINDS[type] == :integer
+      # A Float, and not an Integer standing on the same line: `nan?` is
+      # asked of one and refused by the other, as Ruby refuses it.
+      def self.floating? (type) = KINDS[type] == :real
       def self.real? (type)     = REAL_TYPES.include?(type)
       def self.complex? (type)  = KINDS[type] == :complex
       def self.boolean? (type)  = KINDS[type] == :boolean
       def self.numeric? (type)  = NUMERIC_TYPES.include?(type)
 
       def integer? (type) = self.class.integer?(type)
+      def floating? (type) = self.class.floating?(type)
       def real? (type)    = self.class.real?(type)
       def complex? (type) = self.class.complex?(type)
       def boolean? (type) = self.class.boolean?(type)
@@ -133,17 +137,24 @@ class CArray
       def self.scalar_type (value)
         case value
         when Float   then :double
-        when Integer then :int64
+        when Integer then integer_type(value)
         when Complex then :complex
         else
           # A generator captured by name is worth its own answer: it is not a
           # value the kernel could carry, and what to do instead is the same
           # thing `rand` inside the block is told.
-          if value.is_a?(Random) || value.equal?(Random) || value.equal?(Kernel)
+          #
+          # `::Random` rather than `Random`, though this file is inside
+          # `class CArray` and nothing there shadows it.  A generator of
+          # CArray's own is `CArray::Rng` precisely so that it does not, and
+          # writing the `::` keeps the question this asks legible from the
+          # line rather than from that fact.
+          if value.is_a?(::Random) || value.equal?(::Random) ||
+             value.equal?(Kernel)
             raise Unsupported,
                   "a generator draws in an order a kernel does not fix; fill " \
-                  "an array with `CArray#random!` and read a cell of it, as " \
-                  "the kernel reads any other array"
+                  "an array with `CArray#random!` and read a cell of it, or " \
+                  "draw from `CArray::Rng.new`, which a kernel can reach"
           end
           raise Unsupported,
                 "captured scalars must be Float, Integer or Complex, got " \
@@ -151,6 +162,32 @@ class CArray
         end
       end
 
+      # Which of the two integer widths a captured Integer travels in.  Ruby's
+      # Integer has none, so the value decides: int64 while it fits one, and
+      # uint64 above that, which is the width CArray has for those values and
+      # the one a kernel already computes them in.  A value that fits neither
+      # is refused here rather than packed, because packing it is what would
+      # not say so -- `pack("q")` takes 2**64 modulo the width and hands back
+      # a zero.
+      #
+      # This is the value deciding a type, which nothing else about a capture
+      # does, and it is sound only because the value is in the kernel's cache
+      # key: 5 and 2**63 + 5 are two kernels, compiled and cached apart.
+      INT64_MIN = -(2**63)
+      INT64_MAX = 2**63 - 1
+      UINT64_MAX = 2**64 - 1
+
+      def self.integer_type (value)
+        return :int64 if value >= INT64_MIN && value <= INT64_MAX
+        return :uint64 if value >= 0 && value <= UINT64_MAX
+        raise Unsupported,
+              "#{value} is outside the integers a kernel computes in -- an " \
+              "int64 down to -2**63, a uint64 up to 2**64-1 -- and Ruby's " \
+              "Integer, which has no width, is the only thing here that can " \
+              "hold it. Capture it as a Float where the value's precision " \
+              "allows one"
+      end
+
       def self.storage_type (name)
         return STORAGE_COMPUTATION_TYPES[name] if STORAGE_COMPUTATION_TYPES[name]
         raise Unsupported, "unsupported array data type `#{name}`"
@@ -172,6 +209,12 @@ class CArray
         }
         @bindings = {}
         @binding_counts = Hash.new(0)
+        # The scope nodes open around the statement being typed, outermost
+        # first, which is what an assignment's scope counts along.
+        @scope_nodes = []
+        # A name a `while` gave its first value, by that `while`: after the
+        # loop it may not have one, and the refusal says why.
+        @assigned_in_while = {}
         assign
       end
 
@@ -188,23 +231,126 @@ class CArray
         verify(@body)
       end
 
+      # A local's bindings are numbered per name, from 1: `x` at its first
+      # type is binding 1 and at its second binding 2.  What it is spelled in
+      # C is the generator's business.
       def bind (name, type)
         current = @bindings[name]
         return current.last if current && current.first == type
         @binding_counts[name] += 1
-        suffix = @binding_counts[name] == 1 ? "" : "__#{@binding_counts[name]}"
-        @bindings[name] = [type, :"#{name}#{suffix}"]
+        @bindings[name] = [type, @binding_counts[name]]
         @bindings[name].last
       end
 
+      # A local is declared once per C variable, at the head of the block for
+      # its scope.  A binding the scope already declared is not declared again.
+      def declare (assignment)
+        scope = @scope_nodes.fetch(assignment.scope)
+        entry = [assignment.name, assignment.binding, assignment.type]
+        scope.declarations << entry unless scope.declarations.include?(entry)
+      end
+
+      # The same for an array the body made.  Writing the same constructor
+      # twice in one scope is one C array and one declaration; what it emits
+      # at each statement is the clearing, which is the generator's.
+      def declare_array (declaration)
+        scope = @scope_nodes.fetch(declaration.scope)
+        entry = [declaration.name, declaration.binding,
+                 declaration.storage, declaration.shape, declaration.heap]
+        scope.array_declarations << entry unless scope.array_declarations.include?(entry)
+      end
+
+      # An array's binding is its name's, and what counts as the same one is
+      # the storage type together with the shape: `w` at two shapes is two C
+      # arrays, exactly as `x` at two types is two C variables.
+      def bind_array (declaration)
+        bind(declaration.name,
+             [:local_array, declaration.storage, declaration.shape])
+      end
+
+      # Which of the name's variables a read or a write of an array resolves
+      # to.  The analyzer has already refused a name that holds a number here
+      # and an array there, so what is left to say is that the array reached
+      # for is still bound -- which is what a branch that made it in one arm
+      # only leaves untrue.
+      def array_binding (node)
+        current = @bindings[node.name]
+        wanted = [:local_array, node.storage, node.shape]
+        unless current && current.first == wanted
+          raise Unsupported.new(
+            "`#{node.name}` is not an array here: it is made on only one path " \
+            "to this line, or at another shape, so there is no one C array " \
+            "for it to be. Make it before the branch",
+            node.location)
+        end
+        current.last
+      end
+
       def walk (node)
         case node
         when KernelBody
+          node.declarations = []
+          node.array_declarations = []
+          @scope_nodes.push(node)
           node.statements.each { |statement| walk(statement) }
+          @scope_nodes.pop
         when Assignment
           walk(node.expression)
           node.type = node.expression.type
-          node.binding_name = bind(node.name, node.type)
+          node.binding = bind(node.name, node.type)
+          @assigned_in_while.delete(node.name)
+          declare(node)
+        when ParallelAssignment
+          # The values were made statements of their own by the analyzer, and
+          # stand before the writes.  Walking them in that order is what gives
+          # a name on the left the binding it had on the right: `a, b = b, a`
+          # reads `b` while `b` is still the old one, because the statement
+          # that reads it comes first.
+          node.statements.each { |statement| walk(statement) }
+        when LocalArrayDeclaration
+          # A declaration has no value, so it has no type: what it says is
+          # what to put at the head of the block.  An extent the block wrote
+          # as an expression is an expression, and is typed as one.
+          node.children.each { |extent| walk(extent) }
+          node.binding = bind_array(node)
+          @assigned_in_while.delete(node.name)
+          declare_array(node)
+        when LocalArrayAddress
+          # The address of an array the body made.  Its binding is what says
+          # which C name the callee is handed; there is no value here, so no
+          # computation type either -- the declaration settled what it is.
+          node.binding = array_binding(node)
+          node.type = :address
+        when IntrinsicCall
+          node.binding = array_binding(node)
+          node.type = self.class.storage_type(node.storage)
+          verify_intrinsic_element_type(node)
+        when IntrinsicStatement
+          node.binding = array_binding(node)
+          # What it did is in the array, so there is no value and no type --
+          # the same slot a call to a `void` function leaves empty.
+          node.type = :void
+          verify_intrinsic_element_type(node)
+        when LocalArrayRead
+          node.binding = array_binding(node)
+          walk_local_array_subscripts(node)
+          node.type = self.class.storage_type(node.storage)
+        when LocalArrayWrite
+          node.binding = array_binding(node)
+          walk_local_array_subscripts(node)
+          walk(node.expression)
+          node.type = self.class.storage_type(node.storage)
+        when LocalArrayMaskWrite
+          # A mark rather than a value: it says the cell is missing and
+          # leaves the bytes under it alone, so there is nothing to type
+          # beyond the cell's own storage.
+          node.binding = array_binding(node)
+          walk_local_array_subscripts(node)
+          node.type = self.class.storage_type(node.storage)
+        when LocalArrayMaskTest
+          node.binding = array_binding(node)
+          walk_local_array_subscripts(node)
+          node.type = :boolean
         when ElementWrite
           walk_subscripts(write_subscripts(node))
           walk(node.expression)
@@ -215,12 +361,31 @@ class CArray
         when MaskTest
           walk_subscripts(node.subscripts)
           node.type = :boolean
+        when PointerTest
+          node.type = :boolean
+        when NumericPredicate
+          walk(node.operand)
+          node.type = :boolean
+        when Clamp
+          node.children.each { |child| walk(child) }
+          # The receiver's, which is exact where the three agree -- and
+          # where they do not, verify refuses rather than choosing.
+          node.type = node.value.type
         when InnerLoop
           walk(node.from)
           walk(node.to)
           entering = @bindings.dup
+          node.entering = entering
+          node.declarations = []
+          node.array_declarations = []
+          @scope_nodes.push(node)
           node.statements.each { |statement| walk(statement) }
+          @scope_nodes.pop
           verify_loop_carries_one_type(entering, node)
+          # What the block made is the block's.  Past it, the names outside
+          # are what they were on the way in, carrying whatever type the
+          # body left them -- which the check above says is the same one.
+          @bindings = @bindings.select { |name, _| entering.key?(name) }
         when While
           # The condition first, and that is not only an order: a name the
           # body introduces is not bound yet when the condition is walked, so
@@ -230,6 +395,12 @@ class CArray
           entering = @bindings.dup
           node.statements.each { |statement| walk(statement) }
           verify_loop_carries_one_type(entering, node)
+          # The body may run no passes, so what it gave a first value to may
+          # have none after it -- Ruby's nil, and a C variable nothing wrote.
+          (@bindings.keys - entering.keys).each do |name|
+            @assigned_in_while[name] = node
+          end
+          @bindings = merge_bindings(entering, @bindings)
         when Print
           node.arguments.each { |argument| walk(argument) }
         when CallStatement
@@ -261,7 +432,9 @@ class CArray
           node.alternative.each { |statement| walk(statement) }
           @bindings = merge_bindings(from_consequent, @bindings)
         when IntegerLiteral
-          node.type = :int64
+          # Above 2**63-1 a literal is a uint64, as a captured Integer is;
+          # where it then meets an int64 it is refused (#refuse_wide_literal).
+          node.type = TypeAssignment.integer_type(node.value)
         when FloatLiteral
           node.type = :double
         when ImaginaryLiteral
@@ -286,11 +459,17 @@ class CArray
           node.type = type
         when LocalRead
           current = @bindings[node.name]
+          if !current && (loop = @assigned_in_while[node.name])
+            raise Unsupported.new(
+              "`#{node.name}` is first assigned inside this `while`, which may " \
+              "run no passes; give it a value before the loop",
+              loop.location)
+          end
           unless current
             raise Unsupported.new("`#{node.name}` is read before it is assigned",
                                   node.location)
           end
-          node.type, node.binding_name = current
+          node.type, node.binding = current
         when UnaryMinus
           walk(node.operand)
           node.type = node.operand.type
@@ -359,6 +538,11 @@ class CArray
               node.location)
           end
           node.type = node.result_type
+        when RandomDraw
+          # What the generator's C returns for this draw.  There is nothing
+          # to infer and no argument to convert: a draw reads the state and
+          # nothing the block wrote.
+          node.type = node.kind == :bits ? :uint64 : :double
         when CFunctionCall
           # Nothing is inferred here: the prototype said what the function
           # returns and what it takes, and the arguments are converted to
@@ -385,6 +569,14 @@ class CArray
           walk(node.right)
           node.type =
             if Analyzer::COMPARISON_OPERATORS.include?(node.operator)
+              # Compared in the wider of the two, which for a uint64 against a
+              # negative literal is a uint64 the literal does not fit.
+              if [node.left.type, node.right.type].include?(:uint64)
+                refuse_negative_literal(node.left, node.right)
+                refuse_negative_literal(node.right, node.left)
+                refuse_wide_literal(node.left, node.right)
+                refuse_wide_literal(node.right, node.left)
+              end
               :boolean
             elsif [:<<, :>>].include?(node.operator)
               # A shift takes its count as a number and keeps the type of the
@@ -507,6 +699,48 @@ class CArray
         end
       end
 
+      # Which element types each intrinsic has an answer for.
+      #
+      # `min` / `max` / `sort` put the cells in an order, and neither a
+      # Complex nor a boolean has one -- Ruby refuses `1i < 2i` and
+      # `true < false` as well.  `sum` adds, which a boolean does not do
+      # either: CArray reads the sum of a boolean array as a count, and
+      # counting is a meaning this compiler would be borrowing rather than
+      # deciding.  Write the count into an integer array and sum that.
+      def verify_intrinsic_element_type (node)
+        type = self.class.storage_type(node.storage)
+        if boolean?(type)
+          if node.intrinsic == :sum
+            raise Unsupported.new(
+              "`sum` adds numbers, and `#{node.name}` is a boolean array; " \
+              "CArray reads the sum of one as a count, which is a meaning " \
+              "this would be borrowing rather than deciding. Count into an " \
+              "integer array and sum that",
+              node.location)
+          end
+          raise Unsupported.new(
+            "`#{node.name}` holds `true` and `false`, which do not order " \
+            "each other -- in Ruby either -- so `#{node.intrinsic}` has " \
+            "nothing to compare",
+            node.location)
+        end
+        return unless complex?(type)
+        return if node.intrinsic == :sum
+        raise Unsupported.new(
+          "`#{node.intrinsic}` orders the cells, and `#{node.name}` holds " \
+          "Complex numbers: Ruby does not order Complex numbers either. " \
+          "Take `.abs` or `.real` into a real array first",
+          node.location)
+      end
+
+      # A local array's subscripts are walked the way an operand's are: a
+      # position that is an expression has to be an integer.  An axis the
+      # analyzer settled carries a literal offset rather than a node, and
+      # there is nothing there to type.
+      def walk_local_array_subscripts (node)
+        walk_subscripts(node.subscripts)
+      end
+
       def element_type (array, location)
         @element_types[array] or
           raise Unsupported.new("no array supplied for `#{array}`", location)
@@ -574,9 +808,11 @@ class CArray
       # raises too.  The one crossing Ruby does allow is `flags[i] = 1`, which
       # CArray takes for true -- and only 0 and 1, which is why it has to be a
       # literal here.
-      def verify_storable (node)
-        wanted = @element_types.fetch(node.array, nil)
-        given = node.expression.type
+      # What may be stored where, said about a storage type and a name rather
+      # than about an operand: an array the body made has a storage type of
+      # its own and no entry in the operand table.
+      def verify_storable (name, wanted, expression, location)
+        given = expression.type
         return if boolean?(wanted) && boolean?(given)
         # A Complex does not fit in a real cell, and Ruby says so: assigning
         # one into a float64 CArray raises rather than dropping the imaginary
@@ -584,26 +820,31 @@ class CArray
         # whose imaginary part is zero.
         if complex?(given) && real?(wanted)
           raise Unsupported.new(
-            "`#{node.array}` holds real numbers, and the value stored into " \
+            "`#{name}` holds real numbers, and the value stored into " \
             "it is a Complex; storing one into a real CArray raises in Ruby " \
             "too. Store `.real`, `.imag` or `.abs`",
-            node.location)
+            location)
+        end
+        if wanted == :int64 && expression.is_a?(IntegerLiteral) &&
+           expression.value > INT64_MAX
+          raise Unsupported.new(wide_literal_message(expression.value),
+                                location)
         end
         return if !boolean?(wanted) && numeric?(given)
-        if boolean?(wanted) && node.expression.is_a?(IntegerLiteral) &&
-           [0, 1].include?(node.expression.value)
+        if boolean?(wanted) && expression.is_a?(IntegerLiteral) &&
+           [0, 1].include?(expression.value)
           return
         end
         if boolean?(wanted)
           raise Unsupported.new(
-            "`#{node.array}` is a boolean array, so it holds `true` and " \
+            "`#{name}` is a boolean array, so it holds `true` and " \
             "`false`; storing #{given} into it is what Ruby refuses too",
-            node.location)
+            location)
         end
         raise Unsupported.new(
-          "the value stored into `#{node.array}` is " \
+          "the value stored into `#{name}` is " \
           "#{given || 'undetermined'}, not a number",
-          node.location)
+          location)
       end
 
       # The nodes that arrive without a data type of their own: a literal and
@@ -648,6 +889,9 @@ class CArray
         # side's width rather than the other side widening to Ruby's.
         return scalar.type if KIND_RANK[scalar_kind] > KIND_RANK[typed_kind]
         if scalar_kind == typed_kind
+          refuse_wide_capture(scalar, typed)
+          refuse_negative_literal(scalar, typed)
+          refuse_wide_literal(scalar, typed)
           # The scalar becomes that type rather than being widened to meet it,
           # and says so: a literal emitted as a double would take the C
           # expression back to double however this node is typed.
@@ -656,6 +900,62 @@ class CArray
         typed.type
       end
 
+      # A negative literal meeting a uint64 would take that width and compute
+      # as 2**64 minus its magnitude.  CArray refuses the same operand on a
+      # uint64 array (`RangeError: -1 is out of range for uint64`); a captured
+      # one is refused when the kernel is called, since its value is not part
+      # of the kernel.
+      def refuse_negative_literal (scalar, typed)
+        return unless scalar.is_a?(IntegerLiteral) && scalar.value.negative? &&
+                      typed.type == :uint64
+        raise Unsupported.new(
+          "#{scalar.value} is out of range for uint64: a negative Integer " \
+          "meeting a uint64 would compute as 2**64#{scalar.value}. CArray " \
+          "refuses the same operand. Convert the uint64 side first, " \
+          "`x.to_f` or a signed capture", scalar.location)
+      end
+
+      # An integer literal above 2**63-1 computed as an int64, where it would
+      # wrap to a negative number.  In Ruby it is an Integer, which has no
+      # width; meeting a uint64 or a Float it keeps its value and is accepted.
+      def refuse_wide_literal (scalar, typed)
+        return unless scalar.is_a?(IntegerLiteral) &&
+                      scalar.value > INT64_MAX && typed.type == :int64
+        raise Unsupported.new(wide_literal_message(scalar.value),
+                              scalar.location)
+      end
+
+      def wide_literal_message (value)
+        "#{value} does not fit an int64, which is what it is computed in " \
+        "here, and would wrap to a negative number. Meet it with a uint64 " \
+        "or a Float, or store it into a uint64 array"
+      end
+
+      # A captured Integer above int64 meeting an integer, which absorption
+      # has no answer for: the scalar is supposed to take the other side's
+      # width, and this value did not come from a width -- it came from a Ruby
+      # Integer, which has none.
+      #
+      # CArray refuses the same expression, `u + 2**63` raising `bignum too
+      # big to convert into 'long long'` whatever the array's own type is, and
+      # this follows it rather than inventing an answer beside it.  Where the
+      # other side is a Float or a Complex there is nothing to refuse: the
+      # wider kind wins, CArray converts the same way, and the value reaches a
+      # double as it does in Ruby.
+      def refuse_wide_capture (scalar, typed)
+        return unless scalar.is_a?(CaptureRead) && scalar.type == :uint64
+        width = typed.type == :uint64 ? "a uint64" : "an int64"
+        raise Unsupported.new(
+          "`#{scalar.name}` is a captured Integer above 2**63-1, and it is " \
+          "meeting #{width}: a captured Integer brings no width of its own -- " \
+          "it takes the width of what it meets -- and this value came from " \
+          "none. CArray refuses the same expression, whatever the array's own " \
+          "type is. Give the value a width: `CScalar.uint64() " \
+          "{ #{scalar.name} }`, which a kernel reads as the one-cell array it " \
+          "is",
+          scalar.location)
+      end
+
       def join (left, right)
         return right if left.nil?
         return left if right.nil?
@@ -682,6 +982,60 @@ class CArray
           # Nothing to check: no value is computed.
         when MaskTest
           # Nothing to check: it reads a mask byte.
+        when PointerTest
+          # Nothing to check: it compares an address with NULL.
+        when Clamp
+          node.children.each { |child| verify(child) }
+          types = node.children.map(&:type)
+          unless types.all? { |type| numeric?(type) }
+            raise Unsupported.new("`clamp` orders numbers", node.location)
+          end
+          if complex?(node.value.type)
+            raise Unsupported.new(
+              "`clamp` has no meaning for a Complex, and raises " \
+              "NoMethodError in Ruby; take `.abs` or `.real` first",
+              node.location)
+          end
+          # Ruby hands back the receiver in one branch and a bound in the
+          # other, so where the two are different *classes* the answer's
+          # class is decided by the value: `1.clamp(0.0, 3.0)` is the
+          # Integer 1 and `5.clamp(0.0, 3.0)` the Float 3.0.  No type
+          # assigned here is both, so that is refused rather than settled
+          # one way and wrong the other.
+          #
+          # Two widths of the same class are not that case.  A float32 cell
+          # is a Ruby Float, as a double is, so `f[i].clamp(0.0, 1.0)` has
+          # one class throughout and the answer is the receiver's width --
+          # the rule every other expression over that cell already takes.
+          unless types.map { |type| integer?(type) }.uniq.size == 1
+            value, bound = if integer?(node.value.type)
+                             ["an Integer", "a Float"]
+                           else
+                             ["a Float", "an Integer"]
+                           end
+            raise Unsupported.new(
+              "`clamp` hands back the value or one of the bounds, so with " \
+              "#{value} value and #{bound} bound Ruby's answer is one class " \
+              "in one branch and the other in the other; write the bounds " \
+              "#{integer?(node.value.type) ? 'as Integers' : 'with a decimal point'}",
+              node.location)
+          end
+        when NumericPredicate
+          verify(node.operand)
+          unless numeric?(node.operand.type)
+            raise Unsupported.new("`#{node.name}` asks about a number",
+                                  node.location)
+          end
+          # `nan?` is Float's alone: an Integer has no NaN to be and a
+          # Complex has no such method, and both raise NoMethodError in Ruby
+          # rather than answering false.  `finite?` is on all three.
+          if node.name == :nan? && !floating?(node.operand.type)
+            raise Unsupported.new(
+              "`nan?` is a Float's question -- " \
+              "#{complex?(node.operand.type) ? 'a Complex' : 'an Integer'} " \
+              "has no method by that name and raises NoMethodError in Ruby",
+              node.location)
+          end
         when While
           verify(node.condition)
           unless boolean?(node.condition.type)
@@ -689,6 +1043,8 @@ class CArray
                                   node.condition.location)
           end
           node.statements.each { |statement| verify(statement) }
+        when ParallelAssignment
+          node.statements.each { |statement| verify(statement) }
         when InnerLoop
           [node.from, node.to].each do |bound|
             verify(bound)
@@ -706,7 +1062,46 @@ class CArray
           node.children.each { |child| verify(child) }
         when ElementWrite
           verify(node.expression)
-          verify_storable(node)
+          verify_storable(node.array, @element_types.fetch(node.array, nil),
+                          node.expression, node.location)
+        when LocalArrayDeclaration
+          # No value is computed here.  What there can be is an extent the
+          # block wrote as an expression, and a length is a whole number of
+          # cells -- a Float or a Complex one is not a length at all.
+          node.shape.each_with_index do |extent, axis|
+            next if extent.is_a?(Integer)
+            verify(extent.node)
+            next if integer?(extent.node.type)
+            where = node.shape.size == 1 ? "" : " on axis #{axis}"
+            raise Unsupported.new(
+              "`#{extent.text}` is the length of `#{node.name}`#{where}, and " \
+              "a length is a whole number of cells; this is " \
+              "#{extent.node.type == :boolean ? 'a true or false' : "a #{extent.node.type}"}",
+              node.location)
+          end
+        when LocalArrayAddress
+          # Nothing to check: the declaration was matched against the shape
+          # and the storage type as the block was read.
+        when IntrinsicCall, IntrinsicStatement
+          # The element type was checked as the types were assigned, and the
+          # argument is an array rather than an expression: there is nothing
+          # under here to walk.
+        when LocalArrayRead
+          node.subscripts.each { |_index, offset|
+            verify(offset) if offset.is_a?(Node)
+          }
+        when LocalArrayMaskWrite, LocalArrayMaskTest
+          # Nothing to check: one writes a mask byte and the other reads one.
+          node.subscripts.each { |_index, offset|
+            verify(offset) if offset.is_a?(Node)
+          }
+        when LocalArrayWrite
+          node.subscripts.each { |_index, offset|
+            verify(offset) if offset.is_a?(Node)
+          }
+          verify(node.expression)
+          verify_storable(node.name, self.class.storage_type(node.storage),
+                          node.expression, node.location)
         when LocalRead
           unless node.type
             raise Unsupported.new("`#{node.name}` is read before it is assigned",
@@ -763,6 +1158,14 @@ class CArray
             Analyzer::COMPARISON_OPERATORS.include?(node.operator)
           verify_bitwise(node) if
             Analyzer::BIT_OPERATORS.include?(node.operator)
+          # `true * true` is a NoMethodError in Ruby.  Said here, where the
+          # operator is, rather than wherever the boolean it made ends up.
+          if Analyzer::ARITHMETIC_OPERATORS.include?(node.operator) &&
+             !numeric?(node.type)
+            raise Unsupported.new(
+              "`#{node.operator}` is arithmetic, and `true` and `false` have " \
+              "none, in Ruby either", node.location)
+          end
           # `Complex(1,2) % 2` is a NoMethodError in Ruby: a floored
           # remainder needs an order, and the plane has none.
           if node.operator == :% && complex?(node.type)
@@ -788,20 +1191,6 @@ class CArray
               "Ruby would not; make one of them a Float",
               node.location)
           end
-        when BinaryOperation
-          node.children.each { |child| verify(child) }
-          if Analyzer::COMPARISON_OPERATORS.include?(node.operator)
-            unless numeric?(node.left.type) &&
-                   numeric?(node.right.type)
-              raise Unsupported.new("comparison operands must be numbers",
-                                    node.location)
-            end
-          else
-            unless numeric?(node.type)
-              raise Unsupported.new("`#{node.operator}` operands must be numbers",
-                                    node.location)
-            end
-          end
         else
           node.children.each { |child| verify(child) }
         end

data/lib/carray/jit/version.rb

@@ -1,5 +1,5 @@
 class CArray
   module JIT
-    VERSION = "0.1.2"
+    VERSION = "0.1.4"
   end
 end