adlint 1.0.0 → 1.2.0

data/lib/adlint/c/expr.rb

@@ -40,10 +40,46 @@ module C #:nodoc:
     # NOTE: Host class of this module must include InterpreterMediator,
     #       NotifierMediator and Conversion.
 
+    def execute_object_specifier(node)
+      if variable = variable_named(node.identifier.value)
+        variable.declarations_and_definitions.each do |decl_or_def|
+          decl_or_def.mark_as_referred_by(node.identifier)
+        end
+        if variable.type.array?
+          # NOTE: Array object is referred to derive the start address.
+          # NOTE: Kill this notification not to confuse the W0459 and W0460
+          #       detections of the expression-statement `a[i] = 0;' when
+          #       contents of `a' is not initialized.
+          # _notify_variable_value_referred(node, variable)
+          variable = temporary_variable(pointer_type(variable.type.base_type),
+                                        pointer_value_of(variable))
+        end
+        _notify_object_referred(node, variable)
+        return variable
+      end
+
+      if function = function_named(node.identifier.value)
+        function.declarations_and_definitions.each do |decl_or_def|
+          decl_or_def.mark_as_referred_by(node.identifier)
+        end
+        _notify_object_referred(node, function)
+        return function
+      end
+
+      if enumerator = enumerator_named(node.identifier.value)
+        enumerator.mark_as_referred_by(node.identifier)
+        return temporary_variable(int_type, ScalarValue.of(enumerator.value))
+      end
+
+      define_implicit_function(node.identifier.value)
+    end
+    module_function :execute_object_specifier
+
     def execute_array_subscript_expression(node, object, subscript)
       unless object.variable? && (object.type.array? || object.type.pointer?)
         return temporary_variable
       end
+      _notify_variable_value_referred(node, object)
 
       array_or_pointer = object
 
@@ -54,6 +90,7 @@ module C #:nodoc:
           subscript.value.exist?
         return temporary_variable(result_type)
       end
+      _notify_variable_value_referred(node, subscript)
 
       case
       when array_or_pointer.type.array?
@@ -81,10 +118,7 @@ module C #:nodoc:
       # FIXME: Domain of the subscript may have multiple values.
       subscript_value = int_subscript.value.unique_sample
       if array and inner_variable = array.inner_variable_at(subscript_value)
-        notify_variable_referred(node, inner_variable)
-        unless variable_reassigning?
-          notify_variable_value_referred(node, inner_variable)
-        end
+        _notify_object_referred(node, inner_variable)
         if inner_variable.type.array?
           result = temporary_variable(result_type,
                                       pointer_value_of(inner_variable))
@@ -99,6 +133,7 @@ module C #:nodoc:
                                          int_subscript, array, result)
       result
     end
+    module_function :execute_array_subscript_expression
 
     def execute_function_call_expression(node, object, args)
       if object.function?
@@ -115,8 +150,22 @@ module C #:nodoc:
           return temporary_variable
         end
       end
+      _notify_variable_value_referred(node, object)
+
+      args.each { |arg, expr| _notify_variable_value_referred(expr, arg) }
 
-      result = function.call(interpreter, args)
+      # NOTE: The ISO C99 standard saids;
+      #
+      # 6.5.2.2 Function calls
+      #
+      # Semantics
+      #
+      # 10 The order of evaluation of the function designator, the actual
+      #    arguments, and subexpressions within the actual arguments is
+      #    unspecified, but there is a sequence point before the actual call.
+      notify_sequence_point_reached(SequencePoint.new(node)) unless args.empty?
+
+      result = function.call(interpreter, node, args)
       unless function.builtin?
         notify_function_call_expr_evaled(node, function,
                                          args.map { |arg, expr| arg }, result)
@@ -124,24 +173,23 @@ module C #:nodoc:
 
       result
     end
+    module_function :execute_function_call_expression
 
     def execute_member_access_by_value_expression(node, object)
       unless object.variable? && object.type.composite?
         return temporary_variable
       end
-
       variable = object
+
       member_variable = variable.inner_variable_named(node.identifier.value)
+      _notify_variable_value_referred(node, variable)
 
       # NOTE: `member_variable' is nil when this expression represents the
       #       direct member access extension.
       notify_member_access_expr_evaled(node, variable, member_variable)
 
       if member_variable
-        notify_variable_referred(node, member_variable)
-        unless variable_reassigning?
-          notify_variable_value_referred(node, member_variable)
-        end
+        _notify_object_referred(node, member_variable)
         if member_variable.type.array?
           type = pointer_type(member_variable.type.base_type)
           return temporary_variable(type, pointer_value_of(member_variable))
@@ -151,6 +199,7 @@ module C #:nodoc:
         temporary_variable
       end
     end
+    module_function :execute_member_access_by_value_expression
 
     def execute_member_access_by_pointer_expression(node, object)
       unqualified_type = object.type.unqualify
@@ -159,8 +208,8 @@ module C #:nodoc:
           unqualified_type.base_type.composite?
         return temporary_variable
       end
-
       pointer = object
+
       if pointee = pointee_of(pointer)
         if pointee.type.array?
           if first_element = pointee.inner_variable_at(0)
@@ -170,10 +219,7 @@ module C #:nodoc:
           end
         end
       end
-
-      if variable_reassigning?
-        notify_variable_value_referred(node, pointer)
-      end
+      _notify_variable_value_referred(node, pointer)
 
       if pointee && pointee.type.composite?
         member_variable = pointee.inner_variable_named(node.identifier.value)
@@ -187,10 +233,7 @@ module C #:nodoc:
       notify_member_access_expr_evaled(node, pointer, member_variable)
 
       if member_variable
-        notify_variable_referred(node, member_variable)
-        unless variable_reassigning?
-          notify_variable_value_referred(node, member_variable)
-        end
+        _notify_object_referred(node, member_variable)
         if member_variable.type.array?
           type = pointer_type(member_variable.type.base_type)
           return temporary_variable(type, pointer_value_of(member_variable))
@@ -200,166 +243,169 @@ module C #:nodoc:
         temporary_variable
       end
     end
+    module_function :execute_member_access_by_pointer_expression
 
     def execute_postfix_increment_expression(node, object)
-      if object.variable?
-        variable = object
+      return temporary_variable unless object.variable? && object.type.scalar?
+      variable = object
 
-        if variable.type.scalar?
-          result = temporary_variable(variable.type, variable.value.dup)
-          if variable.value.scalar?
-            variable.assign!(variable.value + ScalarValue.of(1))
-          end
-        else
-          result = temporary_variable
-        end
+      result = temporary_variable(variable.type, variable.value.dup)
 
-        notify_postfix_increment_expr_evaled(node, variable, result)
-        notify_variable_value_updated(node, variable)
+      # NOTE: Value of the variable is referred at this point.  But value
+      #       reference should not be notified not to confuse sequence-point
+      #       warning detections.
+      # _notify_variable_value_referred(node, variable)
 
-        result
-      else
-        temporary_variable
+      if variable.value.scalar?
+        variable.assign!(variable.value + ScalarValue.of(1))
+        _notify_variable_value_updated(node, variable)
       end
+
+      notify_postfix_increment_expr_evaled(node, variable, result)
+
+      result
     end
+    module_function :execute_postfix_increment_expression
 
     def execute_postfix_decrement_expression(node, object)
-      if object.variable?
-        variable = object
+      return temporary_variable unless object.variable? && object.type.scalar?
+      variable = object
 
-        if variable.type.scalar?
-          result = temporary_variable(variable.type, variable.value.dup)
-          if variable.value.scalar?
-            variable.assign!(variable.value - ScalarValue.of(1))
-          end
-        else
-          result = temporary_variable
-        end
+      result = temporary_variable(variable.type, variable.value.dup)
 
-        notify_postfix_decrement_expr_evaled(node, variable, result)
-        notify_variable_value_updated(node, variable)
+      # NOTE: Value of the variable is referred at this point.  But value
+      #       reference should not be notified not to confuse sequence-point
+      #       warnings detections.
+      # _notify_variable_value_referred(node, variable)
 
-        result
-      else
-        temporary_variable
+      if variable.value.scalar?
+        variable.assign!(variable.value - ScalarValue.of(1))
+        _notify_variable_value_updated(node, variable)
       end
+
+      notify_postfix_decrement_expr_evaled(node, variable, result)
+
+      result
     end
+    module_function :execute_postfix_decrement_expression
 
     def execute_prefix_increment_expression(node, object)
-      if object.variable?
-        variable = object
+      return temporary_variable unless object.variable? && object.type.scalar?
+      variable = object
 
-        if variable.type.scalar?
-          original_value = variable.value.dup
-          if variable.value.scalar?
-            variable.assign!(variable.value + ScalarValue.of(1))
-          end
-        else
-          original_value = variable.value.dup
-        end
+      original_value = variable.value.dup
 
-        notify_prefix_increment_expr_evaled(node, variable, original_value)
-        notify_variable_value_updated(node, variable)
+      # NOTE: Value of the variable is referred at this point.  But value
+      #       reference should not be notified not to confuse sequence-point
+      #       warnings detections.
+      # _notify_variable_value_referred(node, variable)
 
-        variable
-      else
-        temporary_variable
+      if variable.value.scalar?
+        variable.assign!(variable.value + ScalarValue.of(1))
+        _notify_variable_value_updated(node, variable)
       end
+
+      notify_prefix_increment_expr_evaled(node, variable, original_value)
+
+      variable
     end
+    module_function :execute_prefix_increment_expression
 
     def execute_prefix_decrement_expression(node, object)
-      if object.variable?
-        variable = object
+      return temporary_variable unless object.variable? && object.type.scalar?
+      variable = object
 
-        if variable.type.scalar?
-          original_value = variable.value.dup
-          if variable.value.scalar?
-            variable.assign!(variable.value - ScalarValue.of(1))
-          end
-        else
-          original_value = variable.value.dup
-        end
+      original_value = variable.value.dup
 
-        notify_prefix_decrement_expr_evaled(node, variable, original_value)
-        notify_variable_value_updated(node, variable)
+      # NOTE: Value of the variable is referred at this point.  But value
+      #       reference should not be notified not to confuse sequence-point
+      #       warning detections.
+      # _notify_variable_value_referred(node, variable)
 
-        variable
-      else
-        temporary_variable
+      if variable.value.scalar?
+        variable.assign!(variable.value - ScalarValue.of(1))
+        _notify_variable_value_updated(node, variable)
       end
-    end
 
-    def execute_indirection_expression(node, object)
-      if object.variable?
-        variable = object
+      notify_prefix_decrement_expr_evaled(node, variable, original_value)
 
-        return temporary_variable unless variable.type.pointer?
+      variable
+    end
+    module_function :execute_prefix_decrement_expression
 
-        pointer = object
-        unqualified_type = pointer.type.unqualify
+    def execute_address_expression(node, object)
+      # NOTE: An address-expression does not read the value of the object.  But
+      #       value reference should be notified to emphasize global variable
+      #       cross-references.
+      _notify_variable_value_referred(node, object)
 
-        pointee = pointee_of(pointer)
-        if variable_reassigning?
-          notify_variable_value_referred(node, pointer)
-        end
+      temporary_variable(pointer_type(object.type), pointer_value_of(object))
+    end
+    module_function :execute_address_expression
 
-        case
-        when pointee
-          if pointee.type.array?
-            if first_element = pointee.inner_variable_at(0)
-              pointee = first_element
-            else
-              pointee = temporary_variable(unqualified_type.base_type)
-            end
-          end
+    def execute_indirection_expression(node, object)
+      return temporary_variable unless object.variable? && object.type.pointer?
+      pointer = object
 
-          unless variable_reassigning?
-            notify_variable_value_referred(node, pointee) if pointee.variable?
-          end
+      unqualified_type = pointer.type.unqualify
+      pointee = pointee_of(pointer)
+      _notify_variable_value_referred(node, pointer)
 
-          unless unqualified_type.base_type.same_as?(pointee.type)
-            pointee =
-              do_conversion(pointee, unqualified_type.base_type) ||
-              temporary_variable(unqualified_type.base_type)
+      case
+      when pointee
+        _notify_object_referred(node, pointee)
+        if pointee.type.array?
+          if first_element = pointee.inner_variable_at(0)
+            pointee = first_element
+          else
+            pointee = temporary_variable(unqualified_type.base_type)
           end
-        when unqualified_type.base_type.function?
-          pointee = define_anonymous_function(unqualified_type.base_type)
-        else
-          pointee = temporary_variable(unqualified_type.base_type)
         end
 
-        notify_indirection_expr_evaled(node, variable, pointee)
-        return pointee
+        unless unqualified_type.base_type.same_as?(pointee.type)
+          pointee =
+            do_conversion(pointee, unqualified_type.base_type) ||
+            temporary_variable(unqualified_type.base_type)
+        end
+      when unqualified_type.base_type.function?
+        pointee = define_anonymous_function(unqualified_type.base_type)
+      else
+        pointee = temporary_variable(unqualified_type.base_type)
       end
 
-      temporary_variable
+      notify_indirection_expr_evaled(node, pointer, pointee)
+
+      pointee
     end
+    module_function :execute_indirection_expression
 
     def execute_unary_arithmetic_expression(node, object)
-      if object.variable? && object.type.scalar?
-        variable = object
+      variable = object_to_variable(object)
+      return temporary_variable unless variable.type.scalar?
 
-        if variable.value.scalar?
-          case node.operator.type
-          when "+"
-            result = temporary_variable(variable.type, +variable.value)
-          when "-"
-            result = temporary_variable(variable.type, -variable.value)
-          when "~"
-            result = temporary_variable(variable.type, ~variable.value)
-          when "!"
-            result = temporary_variable(int_type, !variable.value)
-          else
-            # NOTREACHED
-          end
+      unless variable == object
+        notify_implicit_conv_performed(node.operand, object, variable)
+      end
 
-          notify_unary_arithmetic_expr_evaled(node, variable, result)
-          return result
-        end
+      case node.operator.type
+      when "+"
+        result = temporary_variable(variable.type, +variable.value)
+      when "-"
+        result = temporary_variable(variable.type, -variable.value)
+      when "~"
+        result = temporary_variable(variable.type, ~variable.value)
+      when "!"
+        result = temporary_variable(int_type, !variable.value)
+      else
+        # NOTREACHED
       end
+      _notify_variable_value_referred(node, variable)
 
-      temporary_variable
+      notify_unary_arithmetic_expr_evaled(node, variable, result)
+
+      result
     end
+    module_function :execute_unary_arithmetic_expression
 
     def execute_cast_expression(node, object)
       resolve_unresolved_type(node.type_name)
@@ -370,23 +416,26 @@ module C #:nodoc:
         temporary_variable(node.type_name.type)
 
       notify_explicit_conv_performed(node, variable, converted)
+
       converted
     end
+    module_function :execute_cast_expression
 
     def execute_multiplicative_expression(node, lhs_object, rhs_object)
-      if lhs_object.function? || rhs_object.function?
-        return temporary_variable
-      end
+      lhs_variable = object_to_variable(lhs_object)
+      return temporary_variable unless lhs_variable.type.scalar?
 
-      lhs_variable = lhs_object
-      rhs_variable = rhs_object
-
-      unless lhs_variable.type.scalar? && rhs_variable.type.scalar?
-        return temporary_variable
+      unless lhs_variable == lhs_object
+        notify_implicit_conv_performed(node.lhs_operand,
+                                       lhs_object, lhs_variable)
       end
 
-      unless lhs_variable.value.scalar? && rhs_variable.value.scalar?
-        return temporary_variable
+      rhs_variable = object_to_variable(rhs_object)
+      return temporary_variable unless rhs_variable.type.scalar?
+
+      unless rhs_variable == rhs_object
+        notify_implicit_conv_performed(node.rhs_operand,
+                                       rhs_object, rhs_variable)
       end
 
       lhs_converted, rhs_converted =
@@ -423,26 +472,30 @@ module C #:nodoc:
       else
         # NOTREACHED
       end
+      _notify_variable_value_referred(node, lhs_variable)
+      _notify_variable_value_referred(node, rhs_variable)
 
-      notify_multiplicative_expr_evaled(node,
-                                        lhs_variable, rhs_variable, result)
+      notify_multiplicative_expr_evaled(node, lhs_variable, rhs_variable,
+                                        result)
       result
     end
+    module_function :execute_multiplicative_expression
 
     def execute_additive_expression(node, lhs_object, rhs_object)
-      if lhs_object.function? || rhs_object.function?
-        return temporary_variable
-      end
+      lhs_variable = object_to_variable(lhs_object)
+      return temporary_variable unless lhs_variable.type.scalar?
 
-      lhs_variable = lhs_object
-      rhs_variable = rhs_object
-
-      unless lhs_variable.type.scalar? && rhs_variable.type.scalar?
-        return temporary_variable
+      unless lhs_variable == lhs_object
+        notify_implicit_conv_performed(node.lhs_operand,
+                                       lhs_object, lhs_variable)
       end
 
-      unless lhs_variable.value.scalar? && rhs_variable.value.scalar?
-        return temporary_variable
+      rhs_variable = object_to_variable(rhs_object)
+      return temporary_variable unless rhs_variable.type.scalar?
+
+      unless rhs_variable == rhs_object
+        notify_implicit_conv_performed(node.rhs_operand,
+                                       rhs_object, rhs_variable)
       end
 
       lhs_converted, rhs_converted =
@@ -472,25 +525,30 @@ module C #:nodoc:
       else
         # NOTREACHED
       end
+      _notify_variable_value_referred(node, lhs_variable)
+      _notify_variable_value_referred(node, rhs_variable)
 
       notify_additive_expr_evaled(node, lhs_variable, rhs_variable, result)
+
       result
     end
+    module_function :execute_additive_expression
 
     def execute_shift_expression(node, lhs_object, rhs_object)
-      if lhs_object.function? || rhs_object.function?
-        return temporary_variable
-      end
+      lhs_variable = object_to_variable(lhs_object)
+      return temporary_variable unless lhs_variable.type.scalar?
 
-      lhs_variable = lhs_object
-      rhs_variable = rhs_object
-
-      unless lhs_variable.type.scalar? && rhs_variable.type.scalar?
-        return temporary_variable
+      unless lhs_variable == lhs_object
+        notify_implicit_conv_performed(node.lhs_operand,
+                                       lhs_object, lhs_variable)
       end
 
-      unless lhs_variable.value.scalar? && rhs_variable.value.scalar?
-        return temporary_variable
+      rhs_variable = object_to_variable(rhs_object)
+      return temporary_variable unless rhs_variable.type.scalar?
+
+      unless rhs_variable == rhs_object
+        notify_implicit_conv_performed(node.rhs_operand,
+                                       rhs_object, rhs_variable)
       end
 
       # NOTE: The ISO C99 standard saids;
@@ -528,25 +586,144 @@ module C #:nodoc:
       else
         # NOTREACHED
       end
+      _notify_variable_value_referred(node, lhs_variable)
+      _notify_variable_value_referred(node, rhs_variable)
 
       notify_shift_expr_evaled(node, lhs_variable, rhs_variable, result)
+
       result
     end
+    module_function :execute_shift_expression
 
-    def execute_and_expression(node, lhs_object, rhs_object)
-      if lhs_object.function? || rhs_object.function?
-        return temporary_variable
+    def execute_relational_expression(node, lhs_object, rhs_object)
+      lhs_variable = object_to_variable(lhs_object)
+      unless lhs_variable.type.scalar?
+        return temporary_variable(int_type, ScalarValue.of_arbitrary)
       end
 
-      lhs_variable = lhs_object
-      rhs_variable = rhs_object
+      unless lhs_variable == lhs_object
+        notify_implicit_conv_performed(node.lhs_operand,
+                                       lhs_object, lhs_variable)
+      end
 
-      unless lhs_variable.type.scalar? && rhs_variable.type.scalar?
-        return temporary_variable
+      rhs_variable = object_to_variable(rhs_object)
+      unless rhs_variable.type.scalar?
+        return temporary_variable(int_type, ScalarValue.of_arbitrary)
       end
 
-      unless lhs_variable.value.scalar? && rhs_variable.value.scalar?
-        return temporary_variable
+      unless rhs_variable == rhs_object
+        notify_implicit_conv_performed(node.rhs_operand,
+                                       rhs_object, rhs_variable)
+      end
+
+      lhs_converted, rhs_converted =
+        do_usual_arithmetic_conversion(lhs_variable, rhs_variable)
+
+      unless lhs_variable == lhs_converted
+        notify_implicit_conv_performed(node.lhs_operand,
+                                       lhs_variable, lhs_converted)
+      end
+
+      unless rhs_variable == rhs_converted
+        notify_implicit_conv_performed(node.rhs_operand,
+                                       rhs_variable, rhs_converted)
+      end
+
+      case node.operator.type
+      when "<"
+        result = temporary_variable(int_type,
+                                    lhs_converted.value < rhs_converted.value)
+      when ">"
+        result = temporary_variable(int_type,
+                                    lhs_converted.value > rhs_converted.value)
+      when "<="
+        result = temporary_variable(int_type,
+                                    lhs_converted.value <= rhs_converted.value)
+      when ">="
+        result = temporary_variable(int_type,
+                                    lhs_converted.value >= rhs_converted.value)
+      else
+        # NOTREACHED
+        result = temporary_variable(int_type, ScalarValue.of_arbitrary)
+      end
+      _notify_variable_value_referred(node, lhs_variable)
+      _notify_variable_value_referred(node, rhs_variable)
+
+      notify_relational_expr_evaled(node, lhs_variable, rhs_variable, result)
+
+      result
+    end
+    module_function :execute_relational_expression
+
+    def execute_equality_expression(node, lhs_object, rhs_object)
+      lhs_variable = object_to_variable(lhs_object)
+      unless lhs_variable.type.scalar?
+        return temporary_variable(int_type, ScalarValue.of_arbitrary)
+      end
+
+      unless lhs_variable == lhs_object
+        notify_implicit_conv_performed(node.lhs_operand,
+                                       lhs_object, lhs_variable)
+      end
+
+      rhs_variable = object_to_variable(rhs_object)
+      unless rhs_variable.type.scalar?
+        return temporary_variable(int_type, ScalarValue.of_arbitrary)
+      end
+
+      unless rhs_variable == rhs_object
+        notify_implicit_conv_performed(node.rhs_operand,
+                                       rhs_object, rhs_variable)
+      end
+
+      lhs_converted, rhs_converted =
+        do_usual_arithmetic_conversion(lhs_variable, rhs_variable)
+
+      unless lhs_variable == lhs_converted
+        notify_implicit_conv_performed(node.lhs_operand,
+                                       lhs_variable, lhs_converted)
+      end
+
+      unless rhs_variable == rhs_converted
+        notify_implicit_conv_performed(node.rhs_operand,
+                                       rhs_variable, rhs_converted)
+      end
+
+      case node.operator.type
+      when "=="
+        result = temporary_variable(int_type,
+                                    lhs_converted.value == rhs_converted.value)
+      when "!="
+        result = temporary_variable(int_type,
+                                    lhs_converted.value != rhs_converted.value)
+      else
+        # NOTREACHED
+        result = temporary_variable(int_type, ScalarValue.of_arbitrary)
+      end
+      _notify_variable_value_referred(node, lhs_variable)
+      _notify_variable_value_referred(node, rhs_variable)
+
+      notify_equality_expr_evaled(node, lhs_variable, rhs_variable, result)
+
+      result
+    end
+    module_function :execute_equality_expression
+
+    def execute_and_expression(node, lhs_object, rhs_object)
+      lhs_variable = object_to_variable(lhs_object)
+      return temporary_variable unless lhs_variable.type.scalar?
+
+      unless lhs_variable == lhs_object
+        notify_implicit_conv_performed(node.lhs_operand,
+                                       lhs_object, lhs_variable)
+      end
+
+      rhs_variable = object_to_variable(rhs_object)
+      return temporary_variable unless rhs_variable.type.scalar?
+
+      unless rhs_variable == rhs_object
+        notify_implicit_conv_performed(node.rhs_operand,
+                                       rhs_object, rhs_variable)
       end
 
       lhs_converted, rhs_converted =
@@ -566,25 +743,30 @@ module C #:nodoc:
       #       min-max of the variable type.
       result = temporary_variable(lhs_converted.type,
                                   lhs_converted.value & rhs_converted.value)
+      _notify_variable_value_referred(node, lhs_variable)
+      _notify_variable_value_referred(node, rhs_variable)
 
       notify_and_expr_evaled(node, lhs_variable, rhs_variable, result)
+
       result
     end
+    module_function :execute_and_expression
 
     def execute_exclusive_or_expression(node, lhs_object, rhs_object)
-      if lhs_object.function? || rhs_object.function?
-        return temporary_variable
-      end
+      lhs_variable = object_to_variable(lhs_object)
+      return temporary_variable unless lhs_variable.type.scalar?
 
-      lhs_variable = lhs_object
-      rhs_variable = rhs_object
-
-      unless lhs_variable.type.scalar? && rhs_variable.type.scalar?
-        return temporary_variable
+      unless lhs_variable == lhs_object
+        notify_implicit_conv_performed(node.lhs_operand,
+                                       lhs_object, lhs_variable)
       end
 
-      unless lhs_variable.value.scalar? && rhs_variable.value.scalar?
-        return temporary_variable
+      rhs_variable = object_to_variable(rhs_object)
+      return temporary_variable unless rhs_variable.type.scalar?
+
+      unless rhs_variable == rhs_object
+        notify_implicit_conv_performed(node.rhs_operand,
+                                       rhs_object, rhs_variable)
       end
 
       lhs_converted, rhs_converted =
@@ -604,25 +786,30 @@ module C #:nodoc:
       #       min-max of the variable type.
       result = temporary_variable(lhs_converted.type,
                                   lhs_converted.value ^ rhs_converted.value)
+      _notify_variable_value_referred(node, lhs_variable)
+      _notify_variable_value_referred(node, rhs_variable)
 
       notify_exclusive_or_expr_evaled(node, lhs_variable, rhs_variable, result)
+
       result
     end
+    module_function :execute_exclusive_or_expression
 
     def execute_inclusive_or_expression(node, lhs_object, rhs_object)
-      if lhs_object.function? || rhs_object.function?
-        return temporary_variable
-      end
+      lhs_variable = object_to_variable(lhs_object)
+      return temporary_variable unless lhs_variable.type.scalar?
 
-      lhs_variable = lhs_object
-      rhs_variable = rhs_object
-
-      unless lhs_variable.type.scalar? && rhs_variable.type.scalar?
-        return temporary_variable
+      unless lhs_variable == lhs_object
+        notify_implicit_conv_performed(node.lhs_operand,
+                                       lhs_object, lhs_variable)
       end
 
-      unless lhs_variable.value.scalar? && rhs_variable.type.scalar?
-        return temporary_variable
+      rhs_variable = object_to_variable(rhs_object)
+      return temporary_variable unless rhs_variable.type.scalar?
+
+      unless rhs_variable == rhs_object
+        notify_implicit_conv_performed(node.rhs_operand,
+                                       rhs_object, rhs_variable)
       end
 
       lhs_converted, rhs_converted =
@@ -642,17 +829,18 @@ module C #:nodoc:
       #       min-max of the variable type.
       result = temporary_variable(lhs_converted.type,
                                   lhs_converted.value | rhs_converted.value)
+      _notify_variable_value_referred(node, lhs_variable)
+      _notify_variable_value_referred(node, rhs_variable)
 
       notify_inclusive_or_expr_evaled(node, lhs_variable, rhs_variable, result)
+
       result
     end
+    module_function :execute_inclusive_or_expression
 
     def execute_simple_assignment_expression(node, lhs_object, rhs_object)
-      if lhs_object.variable?
-        lhs_variable = lhs_object
-      else
-        return lhs_object
-      end
+      return lhs_object unless lhs_object.variable?
+      lhs_variable = lhs_object
 
       rhs_variable = object_to_variable(rhs_object)
       unless rhs_variable == rhs_object
@@ -676,29 +864,29 @@ module C #:nodoc:
       #       instantiated in value-coercing.
       #       So, value-aliasing never occurs.
       lhs_variable.assign!(rhs_converted.value.to_defined_value)
+      _notify_variable_value_referred(node, rhs_variable)
+      _notify_variable_value_updated(node, lhs_variable)
+
       notify_assignment_expr_evaled(node, lhs_variable, rhs_converted)
-      notify_variable_value_updated(node, lhs_variable)
 
       lhs_variable
     end
+    module_function :execute_simple_assignment_expression
 
     def execute_compound_assignment_expression(node, lhs_object, rhs_object)
-      if lhs_object.variable?
-        lhs_variable = lhs_object
-      else
-        return lhs_object
+      unless lhs_object.variable? && lhs_object.type.scalar?
+        return temporary_variable
       end
+      lhs_variable = lhs_object
 
       rhs_variable = object_to_variable(rhs_object)
+      return temporary_variable unless rhs_variable.type.scalar?
+
       unless rhs_variable == rhs_object
         notify_implicit_conv_performed(node.rhs_operand,
                                        rhs_object, rhs_variable)
       end
 
-      unless lhs_variable.type.scalar? && rhs_variable.type.scalar?
-        return lhs_variable
-      end
-
       case node.operator.type
       when "*="
         execute_mul_then_assign_expression(node, lhs_variable, rhs_variable)
@@ -722,10 +910,9 @@ module C #:nodoc:
         execute_ior_then_assign_expression(node, lhs_variable, rhs_variable)
       end
 
-      notify_variable_value_updated(node, lhs_variable)
-
       lhs_variable
     end
+    module_function :execute_compound_assignment_expression
 
     def execute_mul_then_assign_expression(node, lhs_variable, rhs_variable)
       lhs_converted, rhs_converted =
@@ -747,6 +934,13 @@ module C #:nodoc:
         result_value = lhs_converted.value
       end
 
+      # NOTE: Value of the lhs_variable is referred at this point.  But value
+      #       reference should not be notified not to confuse sequence-point
+      #       warning detections.
+      # _notify_variable_value_referred(node, lhs_variable)
+
+      _notify_variable_value_referred(node, rhs_variable)
+
       result_variable = temporary_variable(lhs_converted.type, result_value)
 
       notify_multiplicative_expr_evaled(node, lhs_variable, rhs_variable,
@@ -765,8 +959,11 @@ module C #:nodoc:
       # NOTE: Domain of the arithmetic result value will be restricted by
       #       min-max of the variable type.
       lhs_variable.assign!(result_converted.value)
+      _notify_variable_value_updated(node, lhs_variable)
+
       notify_assignment_expr_evaled(node, lhs_variable, result_converted)
     end
+    module_function :execute_mul_then_assign_expression
 
     def execute_div_then_assign_expression(node, lhs_variable, rhs_variable)
       lhs_converted, rhs_converted =
@@ -789,6 +986,13 @@ module C #:nodoc:
         result_value = lhs_converted.value
       end
 
+      # NOTE: Value of the lhs_variable is referred at this point.  But value
+      #       reference should not be notified not to confuse sequence-point
+      #       warning detections.
+      # _notify_variable_value_referred(node, lhs_variable)
+
+      _notify_variable_value_referred(node, rhs_variable)
+
       result_variable = temporary_variable(lhs_converted.type, result_value)
 
       notify_multiplicative_expr_evaled(node, lhs_variable, rhs_variable,
@@ -807,8 +1011,11 @@ module C #:nodoc:
       # NOTE: Domain of the arithmetic result value will be restricted by
       #       min-max of the variable type.
       lhs_variable.assign!(result_converted.value)
+      _notify_variable_value_updated(node, lhs_variable)
+
       notify_assignment_expr_evaled(node, lhs_variable, result_converted)
     end
+    module_function :execute_div_then_assign_expression
 
     def execute_mod_then_assign_expression(node, lhs_variable, rhs_variable)
       lhs_converted, rhs_converted =
@@ -831,6 +1038,13 @@ module C #:nodoc:
         result_value = lhs_converted.value
       end
 
+      # NOTE: Value of the lhs_variable is referred at this point.  But value
+      #       reference should not be notified not to confuse sequence-point
+      #       warning detections.
+      # _notify_variable_value_referred(node, lhs_variable)
+
+      _notify_variable_value_referred(node, rhs_variable)
+
       result_variable = temporary_variable(lhs_converted.type, result_value)
 
       notify_multiplicative_expr_evaled(node, lhs_variable, rhs_variable,
@@ -849,8 +1063,11 @@ module C #:nodoc:
       # NOTE: Domain of the arithmetic result value will be restricted by
       #       min-max of the variable type.
       lhs_variable.assign!(result_converted.value)
+      _notify_variable_value_updated(node, lhs_variable)
+
       notify_assignment_expr_evaled(node, lhs_variable, result_converted)
     end
+    module_function :execute_mod_then_assign_expression
 
     def execute_add_then_assign_expression(node, lhs_variable, rhs_variable)
       lhs_converted, rhs_converted =
@@ -872,6 +1089,13 @@ module C #:nodoc:
         result_value = lhs_converted.value
       end
 
+      # NOTE: Value of the lhs_variable is referred at this point.  But value
+      #       reference should not be notified not to confuse sequence-point
+      #       warning detections.
+      # _notify_variable_value_referred(node, lhs_variable)
+
+      _notify_variable_value_referred(node, rhs_variable)
+
       result_variable = temporary_variable(lhs_converted.type, result_value)
 
       notify_additive_expr_evaled(node, lhs_variable, rhs_variable,
@@ -890,8 +1114,11 @@ module C #:nodoc:
       # NOTE: Domain of the arithmetic result value will be restricted by
       #       min-max of the variable type.
       lhs_variable.assign!(result_converted.value)
+      _notify_variable_value_updated(node, lhs_variable)
+
       notify_assignment_expr_evaled(node, lhs_variable, result_converted)
     end
+    module_function :execute_add_then_assign_expression
 
     def execute_sub_then_assign_expression(node, lhs_variable, rhs_variable)
       lhs_converted, rhs_converted =
@@ -913,6 +1140,13 @@ module C #:nodoc:
         result_value = lhs_converted.value
       end
 
+      # NOTE: Value of the lhs_variable is referred at this point.  But value
+      #       reference should not be notified not to confuse sequence-point
+      #       warning detections.
+      # _notify_variable_value_referred(node, lhs_variable)
+
+      _notify_variable_value_referred(node, rhs_variable)
+
       result_variable = temporary_variable(lhs_converted.type, result_value)
 
       notify_additive_expr_evaled(node, lhs_variable, rhs_variable,
@@ -931,8 +1165,11 @@ module C #:nodoc:
       # NOTE: Domain of the arithmetic result value will be restricted by
       #       min-max of the variable type.
       lhs_variable.assign!(result_converted.value)
+      _notify_variable_value_updated(node, lhs_variable)
+
       notify_assignment_expr_evaled(node, lhs_variable, result_converted)
     end
+    module_function :execute_sub_then_assign_expression
 
     def execute_shl_then_assign_expression(node, lhs_variable, rhs_variable)
       # NOTE: The ISO C99 standard saids;
@@ -962,6 +1199,13 @@ module C #:nodoc:
         result_value = lhs_converted.value
       end
 
+      # NOTE: Value of the lhs_variable is referred at this point.  But value
+      #       reference should not be notified not to confuse sequence-point
+      #       warning detections.
+      # _notify_variable_value_referred(node, lhs_variable)
+
+      _notify_variable_value_referred(node, rhs_variable)
+
       result_variable = temporary_variable(lhs_converted.type, result_value)
 
       notify_shift_expr_evaled(node, lhs_converted, rhs_converted,
@@ -980,7 +1224,11 @@ module C #:nodoc:
       # NOTE: Domain of the arithmetic result value will be restricted by
       #       min-max of the variable type.
       lhs_variable.assign!(result_converted.value)
+      _notify_variable_value_updated(node, lhs_variable)
+
+      notify_assignment_expr_evaled(node, lhs_variable, result_converted)
     end
+    module_function :execute_shl_then_assign_expression
 
     def execute_shr_then_assign_expression(node, lhs_variable, rhs_variable)
       # NOTE: The ISO C99 standard saids;
@@ -1010,6 +1258,13 @@ module C #:nodoc:
         result_value = lhs_converted.value
       end
 
+      # NOTE: Value of the lhs_variable is referred at this point.  But value
+      #       reference should not be notified not to confuse sequence-point
+      #       warning detections.
+      # _notify_variable_value_referred(node, lhs_variable)
+
+      _notify_variable_value_referred(node, rhs_variable)
+
       result_variable = temporary_variable(lhs_converted.type, result_value)
 
       notify_shift_expr_evaled(node, lhs_converted, rhs_converted,
@@ -1028,7 +1283,11 @@ module C #:nodoc:
       # NOTE: Domain of the arithmetic result value will be restricted by
       #       min-max of the variable type.
       lhs_variable.assign!(result_converted.value)
+      _notify_variable_value_updated(node, lhs_variable)
+
+      notify_assignment_expr_evaled(node, lhs_variable, result_converted)
     end
+    module_function :execute_shr_then_assign_expression
 
     def execute_and_then_assign_expression(node, lhs_variable, rhs_variable)
       lhs_converted, rhs_converted =
@@ -1050,6 +1309,13 @@ module C #:nodoc:
         result_value = lhs_converted.value
       end
 
+      # NOTE: Value of the lhs_variable is referred at this point.  But value
+      #       reference should not be notified not to confuse sequence-point
+      #       warning detections.
+      # _notify_variable_value_referred(node, lhs_variable)
+
+      _notify_variable_value_referred(node, rhs_variable)
+
       result_variable = temporary_variable(lhs_converted.type, result_value)
 
       notify_and_expr_evaled(node, lhs_variable, rhs_variable, result_variable)
@@ -1067,8 +1333,11 @@ module C #:nodoc:
       # NOTE: Domain of the arithmetic result value will be restricted by
       #       min-max of the variable type.
       lhs_variable.assign!(result_converted.value)
+      _notify_variable_value_updated(node, lhs_variable)
+
       notify_assignment_expr_evaled(node, lhs_variable, result_converted)
     end
+    module_function :execute_and_then_assign_expression
 
     def execute_xor_then_assign_expression(node, lhs_variable, rhs_variable)
       lhs_converted, rhs_converted =
@@ -1090,6 +1359,13 @@ module C #:nodoc:
         result_value = lhs_converted.value
       end
 
+      # NOTE: Value of the lhs_variable is referred at this point.  But value
+      #       reference should not be notified not to confuse sequence-point
+      #       warning detections.
+      # _notify_variable_value_referred(node, lhs_variable)
+
+      _notify_variable_value_referred(node, rhs_variable)
+
       result_variable = temporary_variable(lhs_converted.type, result_value)
 
       notify_exclusive_or_expr_evaled(node, lhs_variable, rhs_variable,
@@ -1108,8 +1384,11 @@ module C #:nodoc:
       # NOTE: Domain of the arithmetic result value will be restricted by
       #       min-max of the variable type.
       lhs_variable.assign!(result_converted.value)
+      _notify_variable_value_updated(node, lhs_variable)
+
       notify_assignment_expr_evaled(node, lhs_variable, result_converted)
     end
+    module_function :execute_xor_then_assign_expression
 
     def execute_ior_then_assign_expression(node, lhs_variable, rhs_variable)
       lhs_converted, rhs_converted =
@@ -1131,6 +1410,13 @@ module C #:nodoc:
         result_value = lhs_converted.value
       end
 
+      # NOTE: Value of the lhs_variable is referred at this point.  But value
+      #       reference should not be notified not to confuse sequence-point
+      #       warning detections.
+      # _notify_variable_value_referred(node, lhs_variable)
+
+      _notify_variable_value_referred(node, rhs_variable)
+
       result_variable = temporary_variable(lhs_converted.type, result_value)
 
       notify_inclusive_or_expr_evaled(node, lhs_variable, rhs_variable,
@@ -1149,44 +1435,63 @@ module C #:nodoc:
       # NOTE: Domain of the arithmetic result value will be restricted by
       #       min-max of the variable type.
       lhs_variable.assign!(result_converted.value)
+      _notify_variable_value_updated(node, lhs_variable)
+
       notify_assignment_expr_evaled(node, lhs_variable, result_converted)
     end
+    module_function :execute_ior_then_assign_expression
 
-    def variable_reassigning_context(&block)
-      expr_context_stack.push(:variable_reassigning)
-      yield
-    ensure
-      expr_context_stack.pop
+    def _notify_object_referred(node, object)
+      case object
+      when Variable
+        interpreter.notify_variable_referred(node, object)
+      when Function
+        interpreter.notify_function_referred(node, object)
+      end
     end
+    module_function :_notify_object_referred
 
-    def variable_reassigning?
-      expr_context_stack.last == :variable_reassigning
-    end
+    def _notify_variable_value_referred(node, object)
+      if object.kind_of?(InnerVariable)
+        # NOTE: When a value of the inner-variable of array or composite object
+        #       is referred, the outmost variable's value is notified to be
+        #       referred.
+        object = object.owner
+        object = object.owner while object.kind_of?(InnerVariable)
+      end
 
-    def function_calling_context(&block)
-      expr_context_stack.push(:function_calling)
-      yield
-    ensure
-      expr_context_stack.pop
+      if object.variable?
+        interpreter.notify_variable_value_referred(node, object)
+      end
     end
+    module_function :_notify_variable_value_referred
 
-    def function_calling?
-      expr_context_stack.last == :function_calling
-    end
+    def _notify_variable_value_updated(node, object)
+      if object.kind_of?(InnerVariable)
+        # NOTE: When a value of the inner-variable of array or composite object
+        #       is updated, the outmost variable's value is notified to be
+        #       updated.
+        object = object.owner
+        object = object.owner while object.kind_of?(InnerVariable)
+      end
 
-    def expr_context_stack
-      @expr_context_stack ||= []
+      if object.variable?
+        interpreter.notify_variable_value_updated(node, object)
+      end
     end
+    module_function :_notify_variable_value_updated
 
-    def char_array_value(string_literal)
+    def _char_array_value(string_literal)
       chars = string_literal.chars.map { |ch| ScalarValue.of(ch.ord) }
       ArrayValue.new(chars + [ScalarValue.of("\0".ord)])
     end
+    module_function :_char_array_value
 
-    def wchar_array_value(string_literal)
+    def _wchar_array_value(string_literal)
       chars = string_literal.chars.map { |ch| ScalarValue.of(ch.ord) }
       ArrayValue.new(chars + [ScalarValue.of("\0".ord)])
     end
+    module_function :_wchar_array_value
   end
 
   module ExpressionEvaluator
@@ -1207,37 +1512,7 @@ module C #:nodoc:
     def visit_object_specifier(node)
       checkpoint(node.location)
 
-      if variable = variable_named(node.identifier.value)
-        notify_variable_referred(node, variable)
-        unless variable_reassigning?
-          notify_variable_value_referred(node, variable)
-        end
-        variable.declarations_and_definitions.each do |decl_or_def|
-          decl_or_def.mark_as_referred_by(node.identifier)
-        end
-        if variable.type.array?
-          variable = temporary_variable(pointer_type(variable.type.base_type),
-                                        pointer_value_of(variable))
-        end
-        return variable
-      end
-
-      if function = function_named(node.identifier.value)
-        unless function_calling?
-          notify_function_referred(node, function)
-        end
-        function.declarations_and_definitions.each do |decl_or_def|
-          decl_or_def.mark_as_referred_by(node.identifier)
-        end
-        return function
-      end
-
-      if enumerator = enumerator_named(node.identifier.value)
-        enumerator.mark_as_referred_by(node.identifier)
-        return temporary_variable(int_type, ScalarValue.of(enumerator.value))
-      end
-
-      define_implicit_function(node.identifier.value)
+      execute_object_specifier(node)
     end
 
     def visit_constant_specifier(node)
@@ -1257,10 +1532,10 @@ module C #:nodoc:
       case node.literal.value
       when /\A"(.*)"\z/
         array = temporary_variable(array_type(char_type, $1.length + 1),
-                                   char_array_value($1))
+                                   _char_array_value($1))
       when /\AL"(.*)"\z/i
         array = temporary_variable(array_type(wchar_type, $1.length + 1),
-                                   wchar_array_value($1))
+                                   _wchar_array_value($1))
       else
         return temporary_variable(pointer_type(char_type))
       end
@@ -1293,7 +1568,7 @@ module C #:nodoc:
     def visit_function_call_expression(node)
       checkpoint(node.location)
 
-      object = function_calling_context { node.expression.accept(self) }
+      object = node.expression.accept(self)
       args = node.argument_expressions.map { |expr| [expr.accept(self), expr] }
 
       execute_function_call_expression(node, object, args)
@@ -1332,7 +1607,7 @@ module C #:nodoc:
     def visit_postfix_increment_expression(node)
       checkpoint(node.location)
 
-      object = variable_reassigning_context { node.operand.accept(self) }
+      object = node.operand.accept(self)
 
       execute_postfix_increment_expression(node, object)
     end
@@ -1340,7 +1615,7 @@ module C #:nodoc:
     def visit_postfix_decrement_expression(node)
       checkpoint(node.location)
 
-      object = variable_reassigning_context { node.operand.accept(self) }
+      object = node.operand.accept(self)
 
       execute_postfix_decrement_expression(node, object)
     end
@@ -1355,7 +1630,7 @@ module C #:nodoc:
     def visit_prefix_increment_expression(node)
       checkpoint(node.location)
 
-      object = variable_reassigning_context { node.operand.accept(self) }
+      object = node.operand.accept(self)
 
       execute_prefix_increment_expression(node, object)
     end
@@ -1363,7 +1638,7 @@ module C #:nodoc:
     def visit_prefix_decrement_expression(node)
       checkpoint(node.location)
 
-      object = variable_reassigning_context { node.operand.accept(self) }
+      object = node.operand.accept(self)
 
       execute_prefix_decrement_expression(node, object)
     end
@@ -1372,7 +1647,8 @@ module C #:nodoc:
       checkpoint(node.location)
 
       object = node.operand.accept(self)
-      temporary_variable(pointer_type(object.type), pointer_value_of(object))
+
+      execute_address_expression(node, object)
     end
 
     def visit_indirection_expression(node)
@@ -1445,7 +1721,6 @@ module C #:nodoc:
       checkpoint(node.location)
 
       object = node.operand.accept(self)
-
       execute_cast_expression(node, object)
     end
 
@@ -1482,53 +1757,7 @@ module C #:nodoc:
       lhs_object = node.lhs_operand.accept(self)
       rhs_object = node.rhs_operand.accept(self)
 
-      if lhs_object.function? || rhs_object.function?
-        return temporary_variable(int_type)
-      end
-
-      lhs_variable = lhs_object
-      rhs_variable = rhs_object
-
-      unless lhs_variable.type.scalar? && rhs_variable.type.scalar?
-        return temporary_variable(int_type)
-      end
-
-      unless lhs_variable.value.scalar? && rhs_variable.value.scalar?
-        return temporary_variable(int_type)
-      end
-
-      lhs_converted, rhs_converted =
-        do_usual_arithmetic_conversion(lhs_variable, rhs_variable)
-
-      unless lhs_variable == lhs_converted
-        notify_implicit_conv_performed(node.lhs_operand,
-                                       lhs_variable, lhs_converted)
-      end
-
-      unless rhs_variable == rhs_converted
-        notify_implicit_conv_performed(node.rhs_operand,
-                                       rhs_variable, rhs_converted)
-      end
-
-      case node.operator.type
-      when "<"
-        result = temporary_variable(int_type,
-                                    lhs_converted.value < rhs_converted.value)
-      when ">"
-        result = temporary_variable(int_type,
-                                    lhs_converted.value > rhs_converted.value)
-      when "<="
-        result = temporary_variable(int_type,
-                                    lhs_converted.value <= rhs_converted.value)
-      when ">="
-        result = temporary_variable(int_type,
-                                    lhs_converted.value >= rhs_converted.value)
-      else
-        # NOTREACHED
-      end
-
-      notify_relational_expr_evaled(node, lhs_converted, rhs_converted, result)
-      result
+      execute_relational_expression(node, lhs_object, rhs_object)
     end
 
     def visit_equality_expression(node)
@@ -1537,47 +1766,7 @@ module C #:nodoc:
       lhs_object = node.lhs_operand.accept(self)
       rhs_object = node.rhs_operand.accept(self)
 
-      if lhs_object.function? || rhs_object.function?
-        return temporary_variable(int_type)
-      end
-
-      lhs_variable = lhs_object
-      rhs_variable = rhs_object
-
-      unless lhs_variable.type.scalar? && rhs_variable.type.scalar?
-        return temporary_variable(int_type)
-      end
-
-      unless lhs_variable.value.scalar? && rhs_variable.value.scalar?
-        return temporary_variable(int_type)
-      end
-
-      lhs_converted, rhs_converted =
-        do_usual_arithmetic_conversion(lhs_variable, rhs_variable)
-
-      unless lhs_variable == lhs_converted
-        notify_implicit_conv_performed(node.lhs_operand,
-                                       lhs_variable, lhs_converted)
-      end
-
-      unless rhs_variable == rhs_converted
-        notify_implicit_conv_performed(node.rhs_operand,
-                                       rhs_variable, rhs_converted)
-      end
-
-      case node.operator.type
-      when "=="
-        result = temporary_variable(int_type,
-                                    lhs_converted.value == rhs_converted.value)
-      when "!="
-        result = temporary_variable(int_type,
-                                    lhs_converted.value != rhs_converted.value)
-      else
-        # NOTREACHED
-      end
-
-      notify_equality_expr_evaled(node, lhs_converted, rhs_converted, result)
-      result
+      execute_equality_expression(node, lhs_object, rhs_object)
     end
 
     def visit_and_expression(node)
@@ -1695,9 +1884,7 @@ module C #:nodoc:
     def visit_simple_assignment_expression(node)
       checkpoint(node.location)
 
-      lhs_object = variable_reassigning_context {
-        node.lhs_operand.accept(self)
-      }
+      lhs_object = node.lhs_operand.accept(self)
       rhs_object = node.rhs_operand.accept(self)
 
       execute_simple_assignment_expression(node, lhs_object, rhs_object)
@@ -1706,9 +1893,7 @@ module C #:nodoc:
     def visit_compound_assignment_expression(node)
       checkpoint(node.location)
 
-      lhs_object = variable_reassigning_context {
-        node.lhs_operand.accept(self)
-      }
+      lhs_object = node.lhs_operand.accept(self)
       rhs_object = node.rhs_operand.accept(self)
 
       execute_compound_assignment_expression(node, lhs_object, rhs_object)