adlint 3.0.10 → 3.2.0

data/lib/adlint/cc1/type.rb

@@ -2401,9 +2401,9 @@ module Cc1 #:nodoc:
   end
 
   class FunctionType < Type
-    def initialize(type_tbl, retn_type, param_types, have_va_list = false)
-      super(type_tbl, create_name(retn_type, param_types, have_va_list))
-      @return_type = retn_type
+    def initialize(type_tbl, ret_type, param_types, have_va_list = false)
+      super(type_tbl, create_name(ret_type, param_types, have_va_list))
+      @return_type = ret_type
       @parameter_types = param_types
       @have_va_list = have_va_list
     end
@@ -2933,33 +2933,33 @@ module Cc1 #:nodoc:
     end
 
     private
-    def create_name(retn_type, param_types, have_va_list)
-      "#{retn_type.name}(" +
+    def create_name(ret_type, param_types, have_va_list)
+      "#{ret_type.name}(" +
         param_types.map { |type| type.name }.join(", ") +
         (have_va_list ? ",...)" : ")")
     end
 
-    def create_image(retn_type, param_types, have_va_list)
-      "#{retn_type.image}(" +
+    def create_image(ret_type, param_types, have_va_list)
+      "#{ret_type.image}(" +
         param_types.map { |type| type.image }.join(", ") +
         (have_va_list ? ",...)" : ")")
     end
 
-    def create_brief_image(retn_type, param_types, have_va_list)
-      "#{retn_type.brief_image}(" +
+    def create_brief_image(ret_type, param_types, have_va_list)
+      "#{ret_type.brief_image}(" +
         param_types.map { |type| type.brief_image }.join(", ") +
         (have_va_list ? ",...)" : ")")
     end
   end
 
   class FunctionTypeId < TypeId
-    def initialize(retn_type, param_types, have_va_list)
-      super(create_value(retn_type, param_types, have_va_list))
+    def initialize(ret_type, param_types, have_va_list)
+      super(create_value(ret_type, param_types, have_va_list))
     end
 
     private
-    def create_value(retn_type, param_types, have_va_list)
-      "#{retn_type.brief_image}(" +
+    def create_value(ret_type, param_types, have_va_list)
+      "#{ret_type.brief_image}(" +
         param_types.map { |type| type.brief_image }.join(",") +
         (have_va_list ? ",...)" : ")")
     end
@@ -7266,8 +7266,8 @@ module Cc1 #:nodoc:
       ArrayType.new(self, base_type, len)
     end
 
-    def function_type(retn_type, param_types, have_va_list = false)
-      FunctionType.new(self, retn_type, param_types, have_va_list)
+    def function_type(ret_type, param_types, have_va_list = false)
+      FunctionType.new(self, ret_type, param_types, have_va_list)
     end
 
     def builtin_function_type

data/lib/adlint/cc1/value.rb

@@ -43,6 +43,49 @@ module Cc1 #:nodoc:
     end
   end
 
+  # == DESCRIPTION
+  # === TestEvidence class hierarchy
+  #  TestEvidence
+  #    <-- TrivialTestEvidence
+  #    <-- NontrivialTestEvidence
+  #          <-- UndefinableTestEvidence
+  #          <-- NullabilityTestEvidence
+  #          <-- DefinableTestEvidence
+  class TestEvidence
+    def fulfilled?
+      subclass_responsibility
+    end
+
+    def emit_context_messages(report, loc)
+      subclass_responsibility
+    end
+  end
+
+  # == DESCRIPTION
+  # === ValueTest class hierarchy
+  #  ValueTest
+  #    <-- TrivialValueTest
+  #    <-- NontrivialValueTest
+  class ValueTest
+    def initialize(evid)
+      @evidence = evid
+    end
+
+    attr_reader :evidence
+
+    def result
+      subclass_responsibility
+    end
+
+    def true?
+      !!result
+    end
+
+    def false?
+      !true?
+    end
+  end
+
   # == DESCRIPTION
   # === Value class hierarchy
   #  Value
@@ -91,7 +134,7 @@ module Cc1 #:nodoc:
       subclass_responsibility
     end
 
-    def overwrite!(val)
+    def overwrite!(val, tag)
       subclass_responsibility
     end
 
@@ -201,59 +244,67 @@ module Cc1 #:nodoc:
       subclass_responsibility
     end
 
-    def must_be_equal_to?(val)
+    def test_must_be_undefined
+      subclass_responsibility
+    end
+
+    def test_may_be_undefined
+      subclass_responsibility
+    end
+
+    def test_must_be_equal_to(val)
       subclass_responsibility
     end
 
-    def may_be_equal_to?(val)
+    def test_may_be_equal_to(val)
       subclass_responsibility
     end
 
-    def must_not_be_equal_to?(val)
+    def test_must_not_be_equal_to(val)
       subclass_responsibility
     end
 
-    def may_not_be_equal_to?(val)
+    def test_may_not_be_equal_to(val)
       subclass_responsibility
     end
 
-    def must_be_less_than?(val)
+    def test_must_be_less_than(val)
       subclass_responsibility
     end
 
-    def may_be_less_than?(val)
+    def test_may_be_less_than(val)
       subclass_responsibility
     end
 
-    def must_be_greater_than?(val)
+    def test_must_be_greater_than(val)
       subclass_responsibility
     end
 
-    def may_be_greater_than?(val)
+    def test_may_be_greater_than(val)
       subclass_responsibility
     end
 
-    def must_be_undefined?
+    def test_must_be_null
       subclass_responsibility
     end
 
-    def may_be_undefined?
+    def test_may_be_null
       subclass_responsibility
     end
 
-    def must_be_true?
+    def test_must_be_true
       subclass_responsibility
     end
 
-    def may_be_true?
+    def test_may_be_true
       subclass_responsibility
     end
 
-    def must_be_false?
+    def test_must_be_false
       subclass_responsibility
     end
 
-    def may_be_false?
+    def test_may_be_false
       subclass_responsibility
     end
 
@@ -286,20 +337,41 @@ module Cc1 #:nodoc:
     end
   end
 
+  class TrivialTestEvidence < TestEvidence
+    def fulfilled?
+      true
+    end
+
+    def emit_context_messages(report, loc)
+      # NOTE: Evidence of the test result about SingleValue is trivial.
+      #       So, nothing to be complemented.
+      []
+    end
+  end
+
+  class TrivialValueTest < ValueTest
+    def initialize(rslt)
+      super(TrivialTestEvidence.new)
+      @result = rslt
+    end
+
+    attr_reader :result
+  end
+
   class SingleValue < Value
     def multiple?
       false
     end
 
-    def must_be_undefined?
-      self.undefined?
+    def test_must_be_undefined
+      TrivialValueTest.new(self.undefined?)
     end
 
-    def may_be_undefined?
+    def test_may_be_undefined
       # NOTE: SingleValue has exactly one value domain.
       #       So, the value of SingleValue may be undefined when the value
       #       must be undefined.
-      self.must_be_undefined?
+      self.test_must_be_undefined
     end
 
     def to_single_value
@@ -307,6 +379,10 @@ module Cc1 #:nodoc:
     end
 
     private
+    def scalar_value_of_null
+      ScalarValue.of(0, logical_shr?)
+    end
+
     def scalar_value_of_true
       ScalarValue.of_true(logical_shr?)
     end
@@ -412,9 +488,9 @@ module Cc1 #:nodoc:
     end
 
     def contain?(val)
-      case single_val = val.to_single_value
+      case sval = val.to_single_value
       when ScalarValue
-        @domain.contain?(single_val.domain)
+        @domain.contain?(sval.domain)
       else
         false
       end
@@ -428,32 +504,28 @@ module Cc1 #:nodoc:
       @domain.ambiguous?
     end
 
-    def overwrite!(val)
-      case single_val = val.to_single_value
+    def overwrite!(val, *)
+      case sval = val.to_single_value
       when ScalarValue
-        @domain = single_val.domain
+        @domain = sval.domain
       else
         raise TypeError, "cannot overwrite scalar with non-scalar."
       end
     end
 
     def narrow_domain!(op, ope_val)
-      case ope_single_val = ope_val.to_single_value
+      case ope_sval = ope_val.to_single_value
       when ScalarValue
-        orig_dom = @domain
-        @domain = @domain.narrow(op, ope_single_val.domain)
-        !@domain.equal?(orig_dom)
+        @domain = @domain.narrow(op, ope_sval.domain)
       else
         raise TypeError, "cannot narrow scalar value domain with non-scalar."
       end
     end
 
     def widen_domain!(op, ope_val)
-      case ope_single_val = ope_val.to_single_value
+      case ope_sval = ope_val.to_single_value
       when ScalarValue
-        orig_dom = @domain
-        @domain = @domain.widen(op, ope_single_val.domain)
-        !@domain.equal?(orig_dom)
+        @domain = @domain.widen(op, ope_sval.domain)
       else
         raise TypeError, "cannot widen scalar value domain with non-scalar."
       end
@@ -464,9 +536,9 @@ module Cc1 #:nodoc:
     end
 
     def single_value_unified_with(rhs_val)
-      case rhs_single_val = rhs_val.to_single_value
+      case rhs_sval = rhs_val.to_single_value
       when ScalarValue
-        ScalarValue.new(@domain.union(rhs_single_val.domain))
+        ScalarValue.new(@domain.union(rhs_sval.domain))
       else
         raise TypeError, "cannot unify scalar value with non-scalar."
       end
@@ -485,90 +557,90 @@ module Cc1 #:nodoc:
     end
 
     def +(rhs_val)
-      case rhs_single_val = rhs_val.to_single_value
+      case rhs_sval = rhs_val.to_single_value
       when ScalarValue
-        ScalarValue.new(@domain + rhs_single_val.domain)
+        ScalarValue.new(@domain + rhs_sval.domain)
       else
         raise TypeError, "binary operation between scalar and non-scalar."
       end
     end
 
     def -(rhs_val)
-      case rhs_single_val = rhs_val.to_single_value
+      case rhs_sval = rhs_val.to_single_value
       when ScalarValue
-        ScalarValue.new(@domain - rhs_single_val.domain)
+        ScalarValue.new(@domain - rhs_sval.domain)
       else
         raise TypeError, "binary operation between scalar and non-scalar."
       end
     end
 
     def *(rhs_val)
-      case rhs_single_val = rhs_val.to_single_value
+      case rhs_sval = rhs_val.to_single_value
       when ScalarValue
-        ScalarValue.new(@domain * rhs_single_val.domain)
+        ScalarValue.new(@domain * rhs_sval.domain)
       else
         raise TypeError, "binary operation between scalar and non-scalar."
       end
     end
 
     def /(rhs_val)
-      case rhs_single_val = rhs_val.to_single_value
+      case rhs_sval = rhs_val.to_single_value
       when ScalarValue
-        ScalarValue.new(@domain / rhs_single_val.domain)
+        ScalarValue.new(@domain / rhs_sval.domain)
       else
         raise TypeError, "binary operation between scalar and non-scalar."
       end
     end
 
     def %(rhs_val)
-      case rhs_single_val = rhs_val.to_single_value
+      case rhs_sval = rhs_val.to_single_value
       when ScalarValue
-        ScalarValue.new(@domain % rhs_single_val.domain)
+        ScalarValue.new(@domain % rhs_sval.domain)
       else
         raise TypeError, "binary operation between scalar and non-scalar."
       end
     end
 
     def &(rhs_val)
-      case rhs_single_val = rhs_val.to_single_value
+      case rhs_sval = rhs_val.to_single_value
       when ScalarValue
-        ScalarValue.new(@domain & rhs_single_val.domain)
+        ScalarValue.new(@domain & rhs_sval.domain)
       else
         raise TypeError, "binary operation between scalar and non-scalar."
       end
     end
 
     def |(rhs_val)
-      case rhs_single_val = rhs_val.to_single_value
+      case rhs_sval = rhs_val.to_single_value
       when ScalarValue
-        ScalarValue.new(@domain | rhs_single_val.domain)
+        ScalarValue.new(@domain | rhs_sval.domain)
       else
         raise TypeError, "binary operation between scalar and non-scalar."
       end
     end
 
     def ^(rhs_val)
-      case rhs_single_val = rhs_val.to_single_value
+      case rhs_sval = rhs_val.to_single_value
       when ScalarValue
-        ScalarValue.new(@domain ^ rhs_single_val.domain)
+        ScalarValue.new(@domain ^ rhs_sval.domain)
       else
         raise TypeError, "binary operation between scalar and non-scalar."
       end
     end
 
     def <<(rhs_val)
-      case rhs_single_val = rhs_val.to_single_value
+      case rhs_sval = rhs_val.to_single_value
       when ScalarValue
-        ScalarValue.new(@domain << rhs_single_val.domain)
+        ScalarValue.new(@domain << rhs_sval.domain)
       else
         raise TypeError, "binary operation between scalar and non-scalar."
       end
     end
 
     def >>(rhs_val)
-      case rhs_single_val = rhs_val.to_single_value
+      case rhs_sval = rhs_val.to_single_value
       when ScalarValue
-        ScalarValue.new(@domain >> rhs_single_val.domain)
+        ScalarValue.new(@domain >> rhs_sval.domain)
       else
         raise TypeError, "binary operation between scalar and non-scalar."
       end
@@ -579,176 +651,193 @@ module Cc1 #:nodoc:
     end
 
     def <(rhs_val)
-      case rhs_single_val = rhs_val.to_single_value
+      case rhs_sval = rhs_val.to_single_value
       when ScalarValue
-        ScalarValue.new(@domain < rhs_single_val.domain)
+        ScalarValue.new(@domain < rhs_sval.domain)
       else
         raise TypeError, "comparison between scalar and non-scalar."
       end
     end
 
     def >(rhs_val)
-      case rhs_single_val = rhs_val.to_single_value
+      case rhs_sval = rhs_val.to_single_value
       when ScalarValue
-        ScalarValue.new(@domain > rhs_single_val.domain)
+        ScalarValue.new(@domain > rhs_sval.domain)
       else
         raise TypeError, "comparison between scalar and non-scalar."
       end
     end
 
     def ==(rhs_val)
-      case rhs_single_val = rhs_val.to_single_value
+      case rhs_sval = rhs_val.to_single_value
       when ScalarValue
-        ScalarValue.new(@domain == rhs_single_val.domain)
+        ScalarValue.new(@domain == rhs_sval.domain)
       else
         raise TypeError, "comparison between scalar and non-scalar."
       end
     end
 
     def !=(rhs_val)
-      case rhs_single_val = rhs_val.to_single_value
+      case rhs_sval = rhs_val.to_single_value
       when ScalarValue
-        ScalarValue.new(@domain != rhs_single_val.domain)
+        ScalarValue.new(@domain != rhs_sval.domain)
       else
         raise TypeError, "comparison between scalar and non-scalar."
       end
     end
 
     def <=(rhs_val)
-      case rhs_single_val = rhs_val.to_single_value
+      case rhs_sval = rhs_val.to_single_value
       when ScalarValue
-        ScalarValue.new(@domain <= rhs_single_val.domain)
+        ScalarValue.new(@domain <= rhs_sval.domain)
       else
         raise TypeError, "comparison between scalar and non-scalar."
       end
     end
 
     def >=(rhs_val)
-      case rhs_single_val = rhs_val.to_single_value
+      case rhs_sval = rhs_val.to_single_value
       when ScalarValue
-        ScalarValue.new(@domain >= rhs_single_val.domain)
+        ScalarValue.new(@domain >= rhs_sval.domain)
       else
         raise TypeError, "comparison between scalar and non-scalar."
       end
     end
 
     def logical_and(rhs_val)
-      case rhs_single_val = rhs_val.to_single_value
+      case rhs_sval = rhs_val.to_single_value
       when ScalarValue
-        ScalarValue.new(@domain.logical_and(rhs_single_val.domain))
+        ScalarValue.new(@domain.logical_and(rhs_sval.domain))
       else
         raise TypeError, "comparison between scalar and non-scalar."
       end
     end
 
     def logical_or(rhs_val)
-      case rhs_single_val = rhs_val.to_single_value
+      case rhs_sval = rhs_val.to_single_value
       when ScalarValue
-        ScalarValue.new(@domain.logical_or(rhs_single_val.domain))
+        ScalarValue.new(@domain.logical_or(rhs_sval.domain))
       else
         raise TypeError, "comparison between scalar and non-scalar."
       end
     end
 
-    def must_be_equal_to?(val)
-      case single_val = val.to_single_value.dup
+    def test_must_be_equal_to(val)
+      case sval = val.to_single_value.dup
       when ScalarValue
-        comp_val = (self == single_val)
-        single_val.invert_domain!
-        single_val.narrow_domain!(Operator::EQ, self)
-        comp_val.domain.intersect?(scalar_value_of_true.domain) &&
+        comp_val = (self == sval)
+        sval.invert_domain!
+        sval.narrow_domain!(Operator::EQ, self)
+        TrivialValueTest.new(
+          comp_val.domain.intersect?(scalar_value_of_true.domain) &&
           !comp_val.domain.contain?(scalar_value_of_false.domain) &&
-          !@domain.intersect?(single_val.domain)
+          !@domain.intersect?(sval.domain))
       else
         raise TypeError, "comparison between scalar and non-scalar."
       end
     end
 
-    def may_be_equal_to?(val)
-      case single_val = val.to_single_value
+    def test_may_be_equal_to(val)
+      case sval = val.to_single_value
       when ScalarValue
-        (self == single_val).domain.intersect?(scalar_value_of_true.domain)
+        TrivialValueTest.new(
+          (self == sval).domain.intersect?(scalar_value_of_true.domain))
       else
         raise TypeError, "comparison between scalar and non-scalar."
       end
     end
 
-    def must_not_be_equal_to?(val)
-      case single_val = val.to_single_value
+    def test_must_not_be_equal_to(val)
+      case sval = val.to_single_value
       when ScalarValue
-        comp_val = (self != single_val)
-        comp_val.domain.intersect?(scalar_value_of_true.domain) &&
+        comp_val = (self != sval)
+        TrivialValueTest.new(
+          comp_val.domain.intersect?(scalar_value_of_true.domain) &&
           !comp_val.domain.contain?(scalar_value_of_false.domain) &&
-          !@domain.intersect?(single_val.domain)
+          !@domain.intersect?(sval.domain))
       else
         raise TypeError, "comparison between scalar and non-scalar."
       end
     end
 
-    def may_not_be_equal_to?(val)
-      case single_val = val.to_single_value
+    def test_may_not_be_equal_to(val)
+      case sval = val.to_single_value
       when ScalarValue
-        (self != single_val).domain.intersect?(scalar_value_of_true.domain)
+        TrivialValueTest.new(
+          (self != sval).domain.intersect?(scalar_value_of_true.domain))
       else
         raise TypeError, "comparison between scalar and non-scalar."
       end
     end
 
-    def must_be_less_than?(val)
-      case single_val = val.to_single_value
+    def test_must_be_less_than(val)
+      case sval = val.to_single_value
       when ScalarValue
-        comp_val = (self < single_val)
-        comp_val.domain.intersect?(scalar_value_of_true.domain) &&
-          !comp_val.domain.contain?(scalar_value_of_false.domain)
+        comp_val = (self < sval)
+        TrivialValueTest.new(
+          comp_val.domain.intersect?(scalar_value_of_true.domain) &&
+          !comp_val.domain.contain?(scalar_value_of_false.domain))
       else
         raise TypeError, "comparison between scalar and non-scalar."
       end
     end
 
-    def may_be_less_than?(val)
-      case single_val = val.to_single_value
+    def test_may_be_less_than(val)
+      case sval = val.to_single_value
       when ScalarValue
-        (self < single_val).domain.intersect?(scalar_value_of_true.domain)
+        TrivialValueTest.new(
+          (self < sval).domain.intersect?(scalar_value_of_true.domain))
       else
         raise TypeError, "comparison between scalar and non-scalar."
       end
     end
 
-    def must_be_greater_than?(val)
-      case single_val = val.to_single_value
+    def test_must_be_greater_than(val)
+      case sval = val.to_single_value
       when ScalarValue
-        comp_val = (self > single_val)
-        comp_val.domain.intersect?(scalar_value_of_true.domain) &&
-          !comp_val.domain.contain?(scalar_value_of_false.domain)
+        comp_val = (self > sval)
+        TrivialValueTest.new(
+          comp_val.domain.intersect?(scalar_value_of_true.domain) &&
+          !comp_val.domain.contain?(scalar_value_of_false.domain))
       else
         raise TypeError, "comparison between scalar and non-scalar."
       end
     end
 
-    def may_be_greater_than?(val)
-      case single_val = val.to_single_value
+    def test_may_be_greater_than(val)
+      case sval = val.to_single_value
       when ScalarValue
-        (self > single_val).domain.intersect?(scalar_value_of_true.domain)
+        TrivialValueTest.new(
+          (self > sval).domain.intersect?(scalar_value_of_true.domain))
       else
         raise TypeError, "comparison between scalar and non-scalar."
       end
     end
 
-    def must_be_true?
-      self.may_be_equal_to?(scalar_value_of_true) &&
-        self.must_not_be_equal_to?(scalar_value_of_false)
+    def test_must_be_null
+      test_must_be_equal_to(scalar_value_of_null)
     end
 
-    def may_be_true?
-      self.may_be_equal_to?(scalar_value_of_true)
+    def test_may_be_null
+      test_may_be_equal_to(scalar_value_of_null)
     end
 
-    def must_be_false?
-      self.must_be_equal_to?(scalar_value_of_false)
+    def test_must_be_true
+      TrivialValueTest.new(
+        test_may_be_equal_to(scalar_value_of_true).true? &&
+        test_must_not_be_equal_to(scalar_value_of_false).true?)
     end
 
-    def may_be_false?
-      self.may_be_equal_to?(scalar_value_of_false)
+    def test_may_be_true
+      test_may_be_equal_to(scalar_value_of_true)
+    end
+
+    def test_must_be_false
+      test_must_be_equal_to(scalar_value_of_false)
+    end
+
+    def test_may_be_false
+      test_may_be_equal_to(scalar_value_of_false)
     end
 
     def coerce_to(type)
@@ -812,12 +901,10 @@ module Cc1 #:nodoc:
     end
 
     def contain?(val)
-      case single_val = val.to_single_value
+      case sval = val.to_single_value
       when ArrayValue
-        if @values.size == single_val.values.size
-          @values.zip(single_val.values).all? do |lhs, rhs|
-            lhs.contain?(rhs)
-          end
+        if @values.size == sval.values.size
+          @values.zip(sval.values).all? { |lhs, rhs| lhs.contain?(rhs) }
         else
           false
         end
@@ -834,11 +921,11 @@ module Cc1 #:nodoc:
       @values.empty? ? false : @values.all? { |val| val.ambiguous? }
     end
 
-    def overwrite!(val)
-      case single_val = val.to_single_value
+    def overwrite!(val, tag)
+      case sval = val.to_single_value
       when ArrayValue
-        @values.zip(single_val.values).each do |lhs, rhs|
-          rhs && lhs.overwrite!(rhs)
+        @values.zip(sval.values).each do |lhs, rhs|
+          rhs && lhs.overwrite!(rhs, tag)
         end
       else
         raise TypeError, "cannot overwrite array with non-array."
@@ -846,30 +933,30 @@ module Cc1 #:nodoc:
     end
 
     def narrow_domain!(op, ope_val)
-      case ope_single_val = ope_val.to_single_value
+      case ope_sval = ope_val.to_single_value
       when ArrayValue
-        @values.zip(ope_single_val.values).map { |lhs, rhs|
+        @values.zip(ope_sval.values).each do |lhs, rhs|
           if rhs
             lhs.narrow_domain!(op, rhs)
           else
             next
           end
-        }.any?
+        end
       else
         raise TypeError, "cannot narrow array value domain with non-array."
       end
     end
 
     def widen_domain!(op, ope_val)
-      case ope_single_val = ope_val.to_single_value
+      case ope_sval = ope_val.to_single_value
       when ArrayValue
-        @values.zip(ope_single_val.values).map { |lhs, rhs|
+        @values.zip(ope_sval.values).each do |lhs, rhs|
           if rhs
             lhs.widen_domain!(op, rhs)
           else
             next
           end
-        }.any?
+        end
       else
         raise TypeError, "cannot widen array value domain with non-array."
       end
@@ -880,9 +967,9 @@ module Cc1 #:nodoc:
     end
 
     def single_value_unified_with(rhs_val)
-      case rhs_single_val = rhs_val.to_single_value
+      case rhs_sval = rhs_val.to_single_value
       when ArrayValue
-        ArrayValue.new(@values.zip(rhs_single_val.values).map { |lhs, rhs|
+        ArrayValue.new(@values.zip(rhs_sval.values).map { |lhs, rhs|
           lhs.single_value_unified_with(rhs)
         })
       else
@@ -993,10 +1080,10 @@ module Cc1 #:nodoc:
       #       of an array variable should be evaluated into a pointer to the
       #       array body.
       #       So, this comparison operator should not be reached.
-      case rhs_single_val = rhs_val.to_single_value
+      case rhs_sval = rhs_val.to_single_value
       when ArrayValue
-        if @values.size == rhs_single_val.values.size
-          zipped = @values.zip(rhs_single_val.values)
+        if @values.size == rhs_sval.values.size
+          zipped = @values.zip(rhs_sval.values)
           zipped.reduce(scalar_value_of_nil) do |rslt_val, (lhs, rhs)|
             rslt_val.single_value_unified_with(lhs < rhs)
           end
@@ -1013,10 +1100,10 @@ module Cc1 #:nodoc:
       #       of an array variable should be evaluated into a pointer to the
       #       array body.
       #       So, this comparison operator should not be reached.
-      case rhs_single_val = rhs_val.to_single_value
+      case rhs_sval = rhs_val.to_single_value
       when ArrayValue
-        if @values.size == rhs_single_val.values.size
-          zipped = @values.zip(rhs_single_val.values)
+        if @values.size == rhs_sval.values.size
+          zipped = @values.zip(rhs_sval.values)
           zipped.reduce(scalar_value_of_nil) do |rslt_val, (lhs, rhs)|
             rslt_val.single_value_unified_with(lhs > rhs)
           end
@@ -1033,10 +1120,10 @@ module Cc1 #:nodoc:
       #       of an array variable should be evaluated into a pointer to the
       #       array body.
       #       So, this comparison operator should not be reached.
-      case rhs_single_val = rhs_val.to_single_value
+      case rhs_sval = rhs_val.to_single_value
       when ArrayValue
-        if @values.size == rhs_single_value.values.size
-          zipped = @values.zip(rhs_single_val.values)
+        if @values.size == rhs_sval.values.size
+          zipped = @values.zip(rhs_sval.values)
           zipped.reduce(scalar_value_of_nil) do |rslt_val, (lhs, rhs)|
             rslt_val.single_value_unified_with(lhs == rhs)
           end
@@ -1053,10 +1140,10 @@ module Cc1 #:nodoc:
       #       of an array variable should be evaluated into a pointer to the
       #       array body.
       #       So, this comparison operator should not be reached.
-      case rhs_single_val = rhs_val.to_single_value
+      case rhs_sval = rhs_val.to_single_value
       when ArrayValue
-        if @values.size == rhs_single_val.values.size
-          zipped = @values.zip(rhs_single_val.values)
+        if @values.size == rhs_sval.values.size
+          zipped = @values.zip(rhs_sval.values)
           zipped.reduce(scalar_value_of_nil) do |rslt_val, (lhs, rhs)|
             rslt_val.single_value_unified_with(lhs != rhs)
           end
@@ -1073,10 +1160,10 @@ module Cc1 #:nodoc:
       #       of an array variable should be evaluated into a pointer to the
       #       array body.
       #       So, this comparison operator should not be reached.
-      case rhs_single_val = rhs_val.to_single_value
+      case rhs_sval = rhs_val.to_single_value
       when ArrayValue
-        if @values.size == rhs_single_val.values.size
-          zipped = @values.zip(rhs_single_val.values)
+        if @values.size == rhs_sval.values.size
+          zipped = @values.zip(rhs_sval.values)
           zipped.reduce(scalar_value_of_nil) do |rslt_val, (lhs, rhs)|
             rslt_val.single_value_unified_with(lhs <= rhs)
           end
@@ -1093,10 +1180,10 @@ module Cc1 #:nodoc:
       #       of an array variable should be evaluated into a pointer to the
       #       array body.
       #       So, this comparison operator should not be reached.
-      case rhs_single_val = rhs_val.to_single_value
+      case rhs_sval = rhs_val.to_single_value
       when ArrayValue
-        if @values.size == rhs_single_value.values.size
-          zipped = @values.zip(rhs_single_val.values)
+        if @values.size == rhs_sval.values.size
+          zipped = @values.zip(rhs_sval.values)
           zipped.reduce(scalar_value_of_nil) do |rslt_val, (lhs, rhs)|
             rslt_val.single_value_unified_with(lhs >= rhs)
           end
@@ -1113,10 +1200,10 @@ module Cc1 #:nodoc:
       #       of an array variable should be evaluated into a pointer to the
       #       array body.
       #       So, this comparison operator should not be reached.
-      case rhs_single_val = rhs_val.to_single_value
+      case rhs_sval = rhs_val.to_single_value
       when ArrayValue
-        if @values.size == rhs_single_val.values.size
-          zipped = @values.zip(rhs_single_val.values)
+        if @values.size == rhs_sval.values.size
+          zipped = @values.zip(rhs_sval.values)
           zipped.reduce(scalar_value_of_nil) do |rslt_val, (lhs, rhs)|
             rslt_val.single_value_unified_with(lhs.logical_and(rhs))
           end
@@ -1133,10 +1220,10 @@ module Cc1 #:nodoc:
       #       of an array variable should be evaluated into a pointer to the
       #       array body.
       #       So, this comparison operator should not be reached.
-      case rhs_single_val = rhs_val.to_single_value
+      case rhs_sval = rhs_val.to_single_value
       when ArrayValue
-        if @values.size == rhs_single_val.values.size
-          zipped = @values.zip(rhs_single_val.values)
+        if @values.size == rhs_sval.values.size
+          zipped = @values.zip(rhs_sval.values)
           zipped.reduce(scalar_value_of_nil) do |rslt_val, (lhs, rhs)|
             rslt_val.single_value_unified_with(lhs.logical_or(rhs))
           end
@@ -1148,108 +1235,117 @@ module Cc1 #:nodoc:
       end
     end
 
-    def must_be_equal_to?(val)
-      case single_val = val.to_single_value
+    def test_must_be_equal_to(val)
+      case sval = val.to_single_value
       when ArrayValue
-        (self == single_val).must_be_true?
+        TrivialValueTest.new((self == sval).test_must_be_true.result)
       else
         raise TypeError, "comparison between array and non-array."
       end
     end
 
-    def may_be_equal_to?(val)
-      case single_val = val.to_single_value
+    def test_may_be_equal_to(val)
+      case sval = val.to_single_value
       when ArrayValue
-        (self == single_val).may_be_true?
+        TrivialValueTest.new((self == sval).test_may_be_true.result)
       else
         raise TypeError, "comparison between array and non-array."
       end
     end
 
-    def must_not_be_equal_to?(val)
-      case single_val = val.to_single_value
+    def test_must_not_be_equal_to(val)
+      case sval = val.to_single_value
       when ArrayValue
-        (self != single_val).must_be_true?
+        TrivialValueTest.new((self != sval).test_must_be_true.result)
       else
         raise TypeError, "comparison between array and non-array."
       end
     end
 
-    def may_not_be_equal_to?(val)
-      case single_val = val.to_single_value
+    def test_may_not_be_equal_to(val)
+      case sval = val.to_single_value
       when ArrayValue
-        (self != single_val).may_be_true?
+        TrivialValueTest.new((self != sval).test_may_be_true.result)
       else
         raise TypeError, "comparison between array and non-array."
       end
     end
 
-    def must_be_less_than?(val)
-      case single_val = value.to_single_value
+    def test_must_be_less_than(val)
+      case sval = value.to_single_value
       when ArrayValue
-        (self < single_val).must_be_true?
+        TrivialValueTest.new((self < sval).test_must_be_true.result)
       else
         raise TypeError, "comparison between array and non-array."
       end
     end
 
-    def may_be_less_than?(val)
-      case single_val = val.to_single_value
+    def test_may_be_less_than(val)
+      case sval = val.to_single_value
       when ArrayValue
-        (self < single_val).may_be_true?
+        TrivialValueTest.new((self < sval).test_may_be_true.result)
       else
         raise TypeError, "comparison between array and non-array."
       end
     end
 
-    def must_be_greater_than?(val)
-      case single_val = val.to_single_value
+    def test_must_be_greater_than(val)
+      case sval = val.to_single_value
       when ArrayValue
-        (self > single_val).must_be_true?
+        TrivialValueTest.new((self > sval).test_must_be_true.result)
       else
         raise TypeError, "comparison between array and non-array."
       end
     end
 
-    def may_be_greater_than?(val)
-      case single_val = val.to_single_value
+    def test_may_be_greater_than(val)
+      case sval = val.to_single_value
       when ArrayValue
-        (self > single_val).may_be_true?
+        TrivialValueTest.new((self > sval).test_may_be_true.result)
       else
         raise TypeError, "comparison between array and non-array."
       end
     end
 
-    def must_be_true?
+    def test_must_be_null
+      TrivialValueTest.new(@values.all? { |val| val.test_must_be_null.result })
+    end
+
+    def test_may_be_null
+      TrivialValueTest.new(@values.all? { |val| val.test_may_be_null.result })
+    end
+
+    def test_must_be_true
       # NOTE: When an array variable appears in expressions, object-specifier
       #       of an array variable should be evaluated into a pointer to the
       #       array body.
       #       So, this method should not be reached.
-      @values.all? { |val| val.must_be_true? }
+      TrivialValueTest.new(@values.all? { |val| val.test_must_be_true.result })
     end
 
-    def may_be_true?
+    def test_may_be_true
       # NOTE: When an array variable appears in expressions, object-specifier
       #       of an array variable should be evaluated into a pointer to the
       #       array body.
       #       So, this method should not be reached.
-      @values.all? { |val| val.may_be_true? }
+      TrivialValueTest.new(@values.all? { |val| val.test_may_be_true.result })
     end
 
-    def must_be_false?
+    def test_must_be_false
       # NOTE: When an array variable appears in expressions, object-specifier
       #       of an array variable should be evaluated into a pointer to the
       #       array body.
       #       So, this method should not be reached.
-      @values.all? { |val| val.must_be_false? }
+      TrivialValueTest.new(
+        @values.all? { |val| val.test_must_be_false.result })
     end
 
-    def may_be_false?
+    def test_may_be_false
       # NOTE: When an array variable appears in expressions, object-specifier
       #       of an array variable should be evaluated into a pointer to the
       #       array body.
       #       So, this method should not be reached.
-      @values.all? { |val| val.may_be_false? }
+      TrivialValueTest.new(@values.all? { |val| val.test_may_be_false.result })
     end
 
     def coerce_to(type)
@@ -1312,12 +1408,10 @@ module Cc1 #:nodoc:
     end
 
     def contain?(val)
-      case single_val = val.to_single_value
+      case sval = val.to_single_value
       when CompositeValue
-        if @values.size == single_val.values.size
-          @values.zip(single_val.values).all? do |lhs, rhs|
-            lhs.contain?(rhs)
-          end
+        if @values.size == sval.values.size
+          @values.zip(sval.values).all? { |lhs, rhs| lhs.contain?(rhs) }
         else
           false
         end
@@ -1334,11 +1428,11 @@ module Cc1 #:nodoc:
       @values.empty? ? false : @values.all? { |val| val.ambiguous? }
     end
 
-    def overwrite!(val)
-      case single_val = val.to_single_value
+    def overwrite!(val, tag)
+      case sval = val.to_single_value
       when CompositeValue
-        @values.zip(single_val.values).each do |lhs, rhs|
-          rhs && lhs.overwrite!(rhs)
+        @values.zip(sval.values).each do |lhs, rhs|
+          rhs && lhs.overwrite!(rhs, tag)
         end
       else
         raise TypeError, "cannot overwrite composite with non-composite."
@@ -1346,15 +1440,15 @@ module Cc1 #:nodoc:
     end
 
     def narrow_domain!(op, ope_val)
-      case ope_single_val = ope_val.to_single_value
+      case ope_sval = ope_val.to_single_value
       when CompositeValue
-        @values.zip(ope_single_val.values).map { |lhs, rhs|
+        @values.zip(ope_sval.values).each do |lhs, rhs|
           if rhs
             lhs.narrow_domain!(op, rhs)
           else
             next
           end
-        }.any?
+        end
       else
         raise TypeError,
           "cannot narrow composite value domain with non-composite."
@@ -1362,15 +1456,15 @@ module Cc1 #:nodoc:
     end
 
     def widen_domain!(op, ope_val)
-      case ope_single_val = ope_val.to_single_value
+      case ope_sval = ope_val.to_single_value
       when CompositeValue
-        @values.zip(ope_single_val.values).map { |lhs, rhs|
+        @values.zip(ope_sval.values).each do |lhs, rhs|
           if rhs
             lhs.widen_domain!(op, rhs)
           else
             next
           end
-        }.any?
+        end
       else
         raise TypeError,
           "cannot widen composite value domain with non-composite."
@@ -1382,10 +1476,10 @@ module Cc1 #:nodoc:
     end
 
     def single_value_unified_with(rhs_val)
-      case rhs_single_val = rhs_val.to_single_value
+      case rhs_sval = rhs_val.to_single_value
       when CompositeValue
         CompositeValue.new(
-          @values.zip(rhs_single_val.values).map { |lhs, rhs|
+          @values.zip(rhs_sval.values).map { |lhs, rhs|
             lhs.single_value_unified_with(rhs)
           })
       else
@@ -1480,10 +1574,10 @@ module Cc1 #:nodoc:
     def <(rhs_val)
       # NOTE: A composite variable cannot appear in expressions except the
       #       primary-expression(object-specifier followed by `.').
-      case rhs_single_val = rhs_val.to_single_value
+      case rhs_sval = rhs_val.to_single_value
       when CompositeValue
-        if @values.size == rhs_single_val.values.size
-          zipped = @values.zip(rhs_single_val.values)
+        if @values.size == rhs_sval.values.size
+          zipped = @values.zip(rhs_sval.values)
           zipped.reduce(scalar_value_of_nil) do |rslt_val, (lhs, rhs)|
             rslt_val.single_value_unified_with(lhs < rhs)
           end
@@ -1498,10 +1592,10 @@ module Cc1 #:nodoc:
     def >(rhs_val)
       # NOTE: A composite variable cannot appear in expressions except the
       #       primary-expression(object-specifier followed by `.').
-      case rhs_single_val = rhs_val.to_single_value
+      case rhs_sval = rhs_val.to_single_value
       when CompositeValue
-        if @values.size == rhs_single_val.values.size
-          zipped = @values.zip(rhs_single_val.values)
+        if @values.size == rhs_sval.values.size
+          zipped = @values.zip(rhs_sval.values)
           zipped.reduce(scalar_value_of_nil) do |rslt_val, (lhs, rhs)|
             rslt_val.single_value_unified_with(lhs > rhs)
           end
@@ -1516,10 +1610,10 @@ module Cc1 #:nodoc:
     def ==(rhs_val)
       # NOTE: A composite variable cannot appear in expressions except the
       #       primary-expression(object-specifier followed by `.').
-      case rhs_single_val = rhs_val.to_single_value
+      case rhs_sval = rhs_val.to_single_value
       when CompositeValue
-        if @values.size == rhs_single_val.values.size
-          zipped = @values.zip(rhs_single_val.values)
+        if @values.size == rhs_sval.values.size
+          zipped = @values.zip(rhs_sval.values)
           zipped.reduce(scalar_value_of_nil) do |rslt_val, (lhs, rhs)|
             rslt_val.single_value_unified_with(lhs == rhs)
           end
@@ -1534,10 +1628,10 @@ module Cc1 #:nodoc:
     def !=(rhs_val)
       # NOTE: A composite variable cannot appear in expressions except the
       #       primary-expression(object-specifier followed by `.').
-      case rhs_single_val = rhs_val.to_single_value
+      case rhs_sval = rhs_val.to_single_value
       when CompositeValue
-        if @values.size == rhs_single_val.values.size
-          zipped = @values.zip(rhs_single_val.values)
+        if @values.size == rhs_sval.values.size
+          zipped = @values.zip(rhs_sval.values)
           zipped.reduce(scalar_value_of_nil) do |rslt_val, (lhs, rhs)|
             rslt_val.single_value_unified_with(lhs != rhs)
           end
@@ -1552,10 +1646,10 @@ module Cc1 #:nodoc:
     def <=(rhs_val)
       # NOTE: A composite variable cannot appear in expressions except the
       #       primary-expression(object-specifier followed by `.').
-      case rhs_single_val = rhs_val.to_single_value
+      case rhs_sval = rhs_val.to_single_value
       when CompositeValue
-        if @values.size == rhs_single_val.values.size
-          zipped = @values.zip(rhs_single_val.values)
+        if @values.size == rhs_sval.values.size
+          zipped = @values.zip(rhs_sval.values)
           zipped.reduce(scalar_value_of_nil) do |rslt_val, (lhs, rhs)|
             rslt_val.single_value_unified_with(lhs <= rhs)
           end
@@ -1570,10 +1664,10 @@ module Cc1 #:nodoc:
     def >=(rhs_val)
       # NOTE: A composite variable cannot appear in expressions except the
       #       primary-expression(object-specifier followed by `.').
-      case rhs_single_val = rhs_val.to_single_value
+      case rhs_sval = rhs_val.to_single_value
       when CompositeValue
-        if @values.size == rhs_single_val.values.size
-          zipped = @values.zip(rhs_single_val.values)
+        if @values.size == rhs_sval.values.size
+          zipped = @values.zip(rhs_sval.values)
           zipped.reduce(scalar_value_of_nil) do |rslt_val, (lhs, rhs)|
             rslt_val.single_value_unified_with(lhs >= rhs)
           end
@@ -1588,10 +1682,10 @@ module Cc1 #:nodoc:
     def logical_and(rhs_val)
       # NOTE: A composite variable cannot appear in expressions except the
       #       primary-expression(object-specifier followed by `.').
-      case rhs_single_val = rhs_val.to_single_value
+      case rhs_sval = rhs_val.to_single_value
       when CompositeValue
-        if @values.size == rhs_single_val.values.size
-          zipped = @values.zip(rhs_single_val.values)
+        if @values.size == rhs_sval.values.size
+          zipped = @values.zip(rhs_sval.values)
           zipped.reduce(scalar_value_of_nil) do |rslt_val, (lhs, rhs)|
             rslt_val.single_value_unified_with(lhs.logical_and(rhs))
           end
@@ -1606,10 +1700,10 @@ module Cc1 #:nodoc:
     def logical_or(rhs_val)
       # NOTE: A composite variable cannot appear in expressions except the
       #       primary-expression(object-specifier followed by `.').
-      case rhs_single_val = rhs_val.to_single_value
+      case rhs_sval = rhs_val.to_single_value
       when CompositeValue
-        if @values.size == rhs_single_val.values.size
-          zipped = @values.zip(rhs_single_val.values)
+        if @values.size == rhs_sval.values.size
+          zipped = @values.zip(rhs_sval.values)
           zipped.reduce(scalar_value_of_nil) do |rslt_val, (lhs, rhs)|
             rslt_val.single_value_unified_with(lhs.logical_or(rhs))
           end
@@ -1621,100 +1715,109 @@ module Cc1 #:nodoc:
       end
     end
 
-    def must_be_equal_to?(val)
-      case single_val = val.to_single_value
+    def test_must_be_equal_to(val)
+      case sval = val.to_single_value
       when CompositeValue
-        (self == single_val).must_be_true?
+        TrivialValueTest.new((self == sval).test_must_be_true.result)
       else
         raise TypeError, "comparison between composite and non-composite."
       end
     end
 
-    def may_be_equal_to?(val)
-      case single_val = val.to_single_value
+    def test_may_be_equal_to(val)
+      case sval = val.to_single_value
       when CompositeValue
-        (self == single_val).may_be_true?
+        TrivialValueTest.new((self == sval).test_may_be_true.result)
       else
         raise TypeError, "comparison between composite and non-composite."
       end
     end
 
-    def must_not_be_equal_to?(val)
-      case single_val = val.to_single_value
+    def test_must_not_be_equal_to(val)
+      case sval = val.to_single_value
       when CompositeValue
-        (self != single_val).must_be_true?
+        TrivialValueTest.new((self != sval).test_must_be_true.result)
       else
         raise TypeError, "comparison between composite and non-composite."
       end
     end
 
-    def may_not_be_equal_to?(val)
-      case single_val = val.to_single_value
+    def test_may_not_be_equal_to(val)
+      case sval = val.to_single_value
       when CompositeValue
-        (self != single_val).may_be_true?
+        TrivialValueTest.new((self != sval).test_may_be_true.result)
       else
         raise TypeError, "comparison between composite and non-composite."
       end
     end
 
-    def must_be_less_than?(val)
-      case single_val = val.to_single_value
+    def test_must_be_less_than(val)
+      case sval = val.to_single_value
       when CompositeValue
-        (self < single_val).must_be_true?
+        TrivialValueTest.new((self < sval).test_must_be_true.result)
       else
         raise TypeError, "comparison between composite and non-composite."
       end
     end
 
-    def may_be_less_than?(val)
-      case single_val = val.to_single_value
+    def test_may_be_less_than(val)
+      case sval = val.to_single_value
       when CompositeValue
-        (self < single_val).may_be_true?
+        TrivialValueTest.new((self < sval).test_may_be_true.result)
       else
         raise TypeError, "comparison between composite and non-composite."
       end
     end
 
-    def must_be_greater_than?(val)
-      case single_val = val.to_single_value
+    def test_must_be_greater_than(val)
+      case sval = val.to_single_value
       when CompositeValue
-        (self > single_val).must_be_true?
+        TrivialValueTest.new((self > sval).test_must_be_true.result)
       else
         raise TypeError, "comparison between composite and non-composite."
       end
     end
 
-    def may_be_greater_than?(val)
-      case single_val = val.to_single_value
+    def test_may_be_greater_than(val)
+      case sval = val.to_single_value
       when CompositeValue
-        (self > single_val).may_be_true?
+        TrivialValueTest.new((self > sval).test_may_be_true.result)
       else
         raise TypeError, "comparison between composite and non-composite."
       end
     end
 
-    def must_be_true?
+    def test_must_be_null
+      TrivialValueTest.new(@values.all? { |val| val.test_must_be_null.result })
+    end
+
+    def test_may_be_null
+      TrivialValueTest.new(@values.all? { |val| val.test_may_be_null.result })
+    end
+
+    def test_must_be_true
       # NOTE: A composite variable cannot appear in expressions except the
       #       primary-expression(object-specifier followed by `.').
-      @values.all? { |val| val.must_be_true? }
+      TrivialValueTest.new(@values.all? { |val| val.test_must_be_true.result })
     end
 
-    def may_be_true?
+    def test_may_be_true
       # NOTE: A composite variable cannot appear in expressions except the
       #       primary-expression(object-specifier followed by `.').
-      @values.all? { |val| val.may_be_true? }
+      TrivialValueTest.new(@values.all? { |val| val.test_may_be_true.result })
     end
 
-    def must_be_false?
+    def test_must_be_false
       # NOTE: A composite variable cannot appear in expressions except the
       #       primary-expression(object-specifier followed by `.').
-      @values.all? { |val| val.must_be_false? }
+      TrivialValueTest.new(
+        @values.all? { |val| val.test_must_be_false.result })
     end
 
-    def may_be_false?
+    def test_may_be_false
       # NOTE: A composite variable cannot appear in expressions except the
       #       primary-expression(object-specifier followed by `.').
-      @values.all? { |val| val.may_be_false? }
+      TrivialValueTest.new(@values.all? { |val| val.test_may_be_false.result })
     end
 
     def coerce_to(type)
@@ -1749,78 +1852,240 @@ module Cc1 #:nodoc:
     memoize :logical_shr?
   end
 
+  class NontrivialTestEvidence < TestEvidence
+    def initialize(exact)
+      @exact = exact
+      @positive_contribs = []
+      @negative_contribs = []
+    end
+
+    attr_reader :positive_contribs
+    attr_reader :negative_contribs
+
+    def fulfilled?
+      if @exact
+        @negative_contribs.any? { |mval| mval._base.tag.traceable? }
+      else
+        @positive_contribs.any? { |mval| mval._base.tag.traceable? } &&
+          @negative_contribs.any? { |mval| mval._base.tag.traceable? }
+      end
+    end
+
+    def add_positive_contributor(mval)
+      @positive_contribs.push(mval)
+    end
+
+    def add_negative_contributor(mval)
+      @negative_contribs.push(mval)
+    end
+  end
+
+  class UndefinableTestEvidence < NontrivialTestEvidence
+    # NOTE: Context tracing feature will be mixed-in at trace.rb later.
+  end
+
+  class NullabilityTestEvidence < NontrivialTestEvidence
+    # NOTE: Context tracing feature will be mixed-in at trace.rb later.
+  end
+
+  class DefinableTestEvidence < NontrivialTestEvidence
+    # NOTE: Context tracing feature will be mixed-in at trace.rb later.
+
+    def initialize(pred, exact)
+      super(exact)
+      @predicate = pred
+    end
+  end
+
+  class NontrivialValueTest < ValueTest
+    def initialize(evid, exact)
+      super(evid)
+      @exact = exact
+    end
+
+    def result
+      # NOTE: TestEvidence of an NontrivialValueTest must be a kind of
+      #       NontrivialTestEvidence.
+      if @exact
+        !evidence.positive_contribs.empty? && evidence.negative_contribs.empty?
+      else
+        !evidence.positive_contribs.empty?
+      end
+    end
+  end
+
+  class TransitionTag
+    def initialize(by = nil, at = nil)
+      self.by = by
+      self.at = at
+    end
+
+    # NOTE: This value is generated by `by' points to AST nodes.
+    attr_reader :by
+
+    def by=(by)
+      @by = by ? by.dup.compact.uniq : []
+    end
+
+    # NOTE: This value is generated in `at' points to branch trees.
+    attr_reader :at
+
+    def at=(at)
+      @at = at ? at.dup.compact.uniq : []
+    end
+
+    def traceable?
+      !@by.empty?
+    end
+
+    def merge!(tag)
+      if tag
+        if at == tag.at
+          self.by = tag.by + by
+          self.at = tag.at + at
+        else
+          self.by = tag.by
+          self.at = tag.at
+        end
+      end
+    end
+
+    def pretty_print(pp)
+      {
+        by: @by.map(&:location),
+        at: @at.map { |br| br.ctrlexpr.to_expr }.compact.map(&:location)
+      }.pretty_print(pp)
+    end
+  end
+
+  class ValueTransition
+    include Enumerable
+
+    Snapshot = Struct.new(:value, :tag)
+    private_constant :Snapshot
+
+    def initialize(mval)
+      @ordered_snapshots = create_ordered_snapshots(mval)
+    end
+
+    def first
+      @ordered_snapshots.first
+    end
+
+    def last
+      @ordered_snapshots.last
+    end
+
+    def each(&block)
+      if block_given?
+        @ordered_snapshots.each(&block)
+      else
+        to_enum(:each)
+      end
+    end
+
+    private
+    def create_ordered_snapshots(mval)
+      if mval.ancestor
+        older = create_ordered_snapshots(mval.ancestor)
+      else
+        older = []
+      end
+      older.push(Snapshot.new(mval._base.value, mval._base.tag))
+    end
+  end
+
   class MultipleValue < Value
-    def initialize(val, ancestor)
-      @base_value = val.to_single_value
+    Base = Struct.new(:value, :tag)
+    private_constant :Base
+
+    def initialize(val, ancestor, tag)
+      @base = Base.new(val.to_single_value, tag)
       @ancestor = ancestor
       @descendants = []
     end
 
-    attr_reader :base_value
+    attr_reader :ancestor
+
+    def scalar?
+      _base.value.scalar?
+    end
 
-    extend Forwardable
+    def array?
+      _base.value.array?
+    end
 
-    def_delegator :@base_value, :scalar?
-    def_delegator :@base_value, :array?
-    def_delegator :@base_value, :composite?
+    def composite?
+      _base.value.composite?
+    end
 
     def undefined?
-      effective_values.all? { |multi_val| multi_val.base_value.undefined? }
+      effective_values.all? { |mval| mval._base.value.undefined? }
     end
 
     def ambiguous?
-      effective_values.all? { |multi_val| multi_val.base_value.ambiguous? }
+      effective_values.all? { |mval| mval._base.value.ambiguous? }
     end
 
     def exist?
-      effective_values.any? { |multi_val| multi_val.base_value.exist? }
+      effective_values.any? { |mval| mval._base.value.exist? }
     end
 
     def definite?
-      effective_values.all? { |multi_val| multi_val.base_value.definite? }
+      effective_values.all? { |mval| mval._base.value.definite? }
     end
 
     def contain?(val)
-      single_val = val.to_single_value
-      effective_values.all? do |multi_val|
-        multi_val.base_value.contain?(single_val)
-      end
+      sval = val.to_single_value
+      effective_values.any? { |mval| mval._base.value.contain?(sval) }
     end
 
     def multiple?
       true
     end
 
-    def overwrite!(val)
-      single_val = val.to_single_value
-      effective_values.each do |multi_val|
-        multi_val.base_value.overwrite!(single_val)
+    def overwrite!(val, tag)
+      sval = val.to_single_value
+      effective_values.each do |mval|
+        mval._base.value.overwrite!(sval, nil)
+        mval._base.tag.merge!(tag)
       end
     end
 
     def narrow_domain!(op, ope_val)
-      ope_single_val = ope_val.to_single_value
-      effective_values.map { |multi_val|
-        if anc = multi_val.ancestor
-          anc.base_value.narrow_domain!(op.for_complement, ope_single_val)
+      ope_sval = ope_val.to_single_value
+      effective_values.each do |mval|
+        if anc = mval.ancestor
+          anc._base.value.narrow_domain!(op.for_complement, ope_sval)
         end
-        multi_val.base_value.narrow_domain!(op, ope_single_val)
-      }.any?
+        mval._base.value.narrow_domain!(op, ope_sval)
+      end
     end
 
     def widen_domain!(op, ope_val)
-      ope_single_val = ope_val.to_single_value
-      effective_values.map { |multi_val|
-        if anc = multi_val.ancestor
-          anc.base_value.narrow_domain!(op.for_complement, ope_single_val)
-        end
-        multi_val.base_value.widen_domain!(op, ope_single_val)
-      }.any?
+      ope_sval = ope_val.to_single_value
+      effective_values.each do |mval|
+        # NOTE: Value domain widening is used to widen the controlling
+        #       variables's value only when the interpreter simulates an
+        #       iteration statement.
+        #       So, domain complementing is unnecessary for this purpose.
+        #
+        # if anc = mval.ancestor
+        #   anc._base.value.narrow_domain!(op.for_complement, ope_sval)
+        # end
+
+        mval._base.value.widen_domain!(op, ope_sval)
+
+        # NOTE: No code is corresponding to the controlling variable's value
+        #       widenning.
+        mval._base.tag.by = nil
+        mval._base.tag.at = nil
+      end
     end
 
     def invert_domain!
-      effective_values.each do |multi_val|
-        multi_val.base_value.invert_domain!
+      effective_values.each do |mval|
+        mval._base.value.invert_domain!
       end
     end
 
@@ -1829,13 +2094,15 @@ module Cc1 #:nodoc:
     end
 
     def fork
-      same_val = @descendants.find { |multi_val| multi_val.eql?(@base_value) }
+      same_val = @descendants.find { |desc| desc.eql?(_base.value) }
       if same_val
+        same_val._base.tag.by = _base.tag.by + same_val._base.tag.by
+        same_val._base.tag.at = _base.tag.at + same_val._base.tag.at
         same_val
       else
-        new_descendant = MultipleValue.new(@base_value.dup, self)
-        @descendants.push(new_descendant)
-        new_descendant
+        MultipleValue.new(_base.value.dup, self, _base.tag.dup).tap do |desc|
+          @descendants.push(desc)
+        end
       end
     end
 
@@ -1935,143 +2202,276 @@ module Cc1 #:nodoc:
       to_single_value.logical_or(rhs_val.to_single_value)
     end
 
-    def must_be_equal_to?(val)
-      single_val = val.to_single_value
-      non_nil_vals = effective_values.select { |multi_val|
-        multi_val.base_value.exist?
-      }
+    def test_must_be_undefined
+      evid = UndefinableTestEvidence.new(true)
+      effective_values.each do |mval|
+        if mval._base.value.test_must_be_undefined.true?
+          evid.add_positive_contributor(mval)
+        else
+          evid.add_negative_contributor(mval)
+        end
+        break if evid.fulfilled?
+      end
+      NontrivialValueTest.new(evid, true)
+    end
+
+    def test_may_be_undefined
+      evid = UndefinableTestEvidence.new(false)
+      effective_values.each do |mval|
+        if mval._base.value.test_may_be_undefined.true?
+          evid.add_positive_contributor(mval)
+        else
+          evid.add_negative_contributor(mval)
+        end
+        break if evid.fulfilled?
+      end
+      NontrivialValueTest.new(evid, false)
+    end
 
+    def test_must_be_equal_to(val)
+      sval = val.to_single_value
+      non_nil_vals = effective_values.select { |mval| mval._base.value.exist? }
       if non_nil_vals.empty?
-        false
+        TrivialValueTest.new(false)
       else
-        non_nil_vals.all? do |multi_val|
-          multi_val.base_value.must_be_equal_to?(single_val)
+        pred = lambda { |v| v.test_must_be_equal_to(sval).true? }
+        evid = DefinableTestEvidence.new(pred, true)
+        non_nil_vals.each do |mval|
+          if pred.call(mval._base.value)
+            evid.add_positive_contributor(mval)
+          else
+            evid.add_negative_contributor(mval)
+          end
+          break if evid.fulfilled?
         end
+        NontrivialValueTest.new(evid, true)
       end
     end
 
-    def may_be_equal_to?(val)
-      single_val = val.to_single_value
-      effective_values.any? do |multi_val|
-        multi_val.base_value.may_be_equal_to?(single_val)
+    def test_may_be_equal_to(val)
+      sval = val.to_single_value
+      pred = lambda { |v| v.test_may_be_equal_to(sval).true? }
+      evid = DefinableTestEvidence.new(pred, false)
+      effective_values.each do |mval|
+        if pred.call(mval._base.value)
+          evid.add_positive_contributor(mval)
+        else
+          evid.add_negative_contributor(mval)
+        end
+        break if evid.fulfilled?
       end
+      NontrivialValueTest.new(evid, false)
     end
 
-    def must_not_be_equal_to?(val)
-      single_val = val.to_single_value
-      non_nil_vals = effective_values.select { |multi_val|
-        multi_val.base_value.exist?
-      }
+    def test_must_not_be_equal_to(val)
+      sval = val.to_single_value
+      non_nil_vals = effective_values.select { |mval| mval._base.value.exist? }
       if non_nil_vals.empty?
-        false
+        TrivialValueTest.new(false)
       else
-        non_nil_vals.all? do |multi_val|
-          multi_val.base_value.must_not_be_equal_to?(single_val)
+        pred = lambda { |v| v.test_must_not_be_equal_to(sval).true? }
+        evid = DefinableTestEvidence.new(pred, true)
+        non_nil_vals.each do |mval|
+          if pred.call(mval._base.value)
+            evid.add_positive_contributor(mval)
+          else
+            evid.add_negative_contributor(mval)
+          end
+          break if evid.fulfilled?
         end
+        NontrivialValueTest.new(evid, true)
       end
     end
 
-    def may_not_be_equal_to?(val)
-      single_val = val.to_single_value
-      effective_values.any? do |multi_val|
-        multi_val.base_value.may_not_be_equal_to?(single_val)
+    def test_may_not_be_equal_to(val)
+      sval = val.to_single_value
+      pred = lambda { |v| v.test_may_not_be_equal_to(sval).true? }
+      evid = DefinableTestEvidence.new(pred, false)
+      effective_values.each do |mval|
+        if pred.call(mval._base.value)
+          evid.add_positive_contributor(mval)
+        else
+          evid.add_negative_contributor(mval)
+        end
+        break if evid.fulfilled?
       end
+      NontrivialValueTest.new(evid, false)
     end
 
-    def must_be_less_than?(val)
-      single_val = val.to_single_value
-      non_nil_vals = effective_values.select { |multi_val|
-        multi_val.base_value.exist?
-      }
+    def test_must_be_less_than(val)
+      sval = val.to_single_value
+      non_nil_vals = effective_values.select { |mval| mval._base.value.exist? }
       if non_nil_vals.empty?
-        false
+        TrivialValueTest.new(false)
       else
-        non_nil_vals.all? do |multi_val|
-          multi_val.base_value.must_be_less_than?(single_val)
+        pred = lambda { |v| v.test_must_be_less_than(sval).true? }
+        evid = DefinableTestEvidence.new(pred, true)
+        non_nil_vals.each do |mval|
+          if pred.call(mval._base.value)
+            evid.add_positive_contributor(mval)
+          else
+            evid.add_negative_contributor(mval)
+          end
+          break if evid.fulfilled?
         end
+        NontrivialValueTest.new(evid, true)
       end
     end
 
-    def may_be_less_than?(val)
-      single_val = val.to_single_value
-      effective_values.any? do |multi_val|
-        multi_val.base_value.may_be_less_than?(single_val)
+    def test_may_be_less_than(val)
+      sval = val.to_single_value
+      pred = lambda { |v| v.test_may_be_less_than(sval).true? }
+      evid = DefinableTestEvidence.new(pred, false)
+      effective_values.each do |mval|
+        if pred.call(mval._base.value)
+          evid.add_positive_contributor(mval)
+        else
+          evid.add_negative_contributor(mval)
+        end
+        break if evid.fulfilled?
       end
+      NontrivialValueTest.new(evid, false)
     end
 
-    def must_be_greater_than?(val)
-      single_val = val.to_single_value
-      non_nil_vals = effective_values.select { |multi_val|
-        multi_val.base_value.exist?
-      }
+    def test_must_be_greater_than(val)
+      sval = val.to_single_value
+      non_nil_vals = effective_values.select { |mval| mval._base.value.exist? }
       if non_nil_vals.empty?
-        false
+        TrivialValueTest.new(false)
       else
-        non_nil_vals.all? do |multi_val|
-          multi_val.base_value.must_be_greater_than?(single_val)
+        pred = lambda { |v| v.test_must_be_greater_than(sval).true? }
+        evid = DefinableTestEvidence.new(pred, true)
+        non_nil_vals.each do |mval|
+          if pred.call(mval._base.value)
+            evid.add_positive_contributor(mval)
+          else
+            evid.add_negative_contributor(mval)
+          end
+          break if evid.fulfilled?
         end
+        NontrivialValueTest.new(evid, true)
       end
     end
 
-    def may_be_greater_than?(val)
-      single_val = val.to_single_value
-      effective_values.any? do |multi_val|
-        multi_val.base_value.may_be_greater_than?(single_val)
+    def test_may_be_greater_than(val)
+      sval = val.to_single_value
+      pred = lambda { |v| v.test_may_be_greater_than(sval).true? }
+      evid = DefinableTestEvidence.new(pred, false)
+      effective_values.any? do |mval|
+        if pred.call(mval._base.value)
+          evid.add_positive_contributor(mval)
+        else
+          evid.add_negative_contributor(mval)
+        end
+        break if evid.fulfilled?
       end
+      NontrivialValueTest.new(evid, false)
     end
 
-    def must_be_undefined?
-      effective_values.all? do |multi_val|
-        multi_val.base_value.must_be_undefined?
+    def test_must_be_null
+      non_nil_vals = effective_values.select { |mval| mval._base.value.exist? }
+      if non_nil_vals.empty?
+        TrivialValueTest.new(false)
+      else
+        evid = NullabilityTestEvidence.new(true)
+        non_nil_vals.each do |mval|
+          if mval._base.value.test_must_be_null.true?
+            evid.add_positive_contributor(mval)
+          else
+            evid.add_negative_contributor(mval)
+          end
+          break if evid.fulfilled?
+        end
+        NontrivialValueTest.new(evid, true)
       end
     end
 
-    def may_be_undefined?
-      effective_values.any? do |multi_val|
-        multi_val.base_value.may_be_undefined?
+    def test_may_be_null
+      evid = NullabilityTestEvidence.new(false)
+      effective_values.each do |mval|
+        if mval._base.value.test_may_be_null.true?
+          evid.add_positive_contributor(mval)
+        else
+          evid.add_negative_contributor(mval)
+        end
+        break if evid.fulfilled?
       end
+      NontrivialValueTest.new(evid, false)
     end
 
-    def must_be_true?
-      non_nil_vals = effective_values.select { |multi_val|
-        multi_val.base_value.exist?
-      }
+    def test_must_be_true
+      non_nil_vals = effective_values.select { |mval| mval._base.value.exist? }
       if non_nil_vals.empty?
-        false
+        TrivialValueTest.new(false)
       else
-        non_nil_vals.all? do |multi_val|
-          multi_val.base_value.must_be_true?
+        pred = lambda { |val| val.test_must_be_true.true? }
+        evid = DefinableTestEvidence.new(pred, true)
+        non_nil_vals.each do |mval|
+          if pred.call(mval._base.value)
+            evid.add_positive_contributor(mval)
+          else
+            evid.add_negative_contributor(mval)
+          end
+          break if evid.fulfilled?
         end
+        NontrivialValueTest.new(evid, true)
       end
     end
 
-    def may_be_true?
-      effective_values.any? do |multi_val|
-        multi_val.base_value.may_be_true?
+    def test_may_be_true
+      pred = lambda { |val| val.test_may_be_true.true? }
+      evid = DefinableTestEvidence.new(pred, false)
+      effective_values.each do |mval|
+        if pred.call(mval._base.value)
+          evid.add_positive_contributor(mval)
+        else
+          evid.add_negative_contributor(mval)
+        end
+        break if evid.fulfilled?
       end
+      NontrivialValueTest.new(evid, false)
     end
 
-    def must_be_false?
-      non_nil_vals = effective_values.select { |multi_val|
-        multi_val.base_value.exist?
-      }
+    def test_must_be_false
+      non_nil_vals = effective_values.select { |mval| mval._base.value.exist? }
       if non_nil_vals.empty?
-        false
+        TrivialValueTest.new(false)
       else
-        non_nil_vals.all? do |multi_val|
-          multi_val.base_value.must_be_false?
+        pred = lambda { |val| val.test_must_be_false.true? }
+        evid = DefinableTestEvidence.new(pred, true)
+        non_nil_vals.each do |mval|
+          if pred.call(mval._base.value)
+            evid.add_positive_contributor(mval)
+          else
+            evid.add_negative_contributor(mval)
+          end
+          break if evid.fulfilled?
         end
+        NontrivialValueTest.new(evid, true)
       end
     end
 
-    def may_be_false?
-      effective_values.any? do |multi_val|
-        multi_val.base_value.may_be_false?
+    def test_may_be_false
+      pred = lambda { |val| val.test_may_be_false.true? }
+      evid = DefinableTestEvidence.new(pred, false)
+      effective_values.each do |mval|
+        if pred.call(mval._base.value)
+          evid.add_positive_contributor(mval)
+        else
+          evid.add_negative_contributor(mval)
+        end
+        break if evid.fulfilled?
       end
+      NontrivialValueTest.new(evid, false)
+    end
+
+    def transition
+      ValueTransition.new(self)
     end
 
     def coerce_to(type)
-      MultipleValue.new(to_single_value.coerce_to(type), nil)
+      sval = to_single_value.coerce_to(type)
+      MultipleValue.new(sval, nil, _base.tag.dup)
     end
 
     def to_enum
@@ -2079,12 +2479,11 @@ module Cc1 #:nodoc:
     end
 
     def to_single_value
-      # NOTE: The base_value of the MultipleValue object must be a SingleValue.
-      effective_values.map { |multi_val|
-        multi_val.base_value
-      }.reduce do |unified_val, single_val|
-        unified_val.single_value_unified_with(single_val)
-      end
+      # NOTE: The _base.value of the MultipleValue object must be a
+      #       SingleValue.
+      effective_values.map { |mval| mval._base.value }.reduce { |unified, sval|
+        unified.single_value_unified_with(sval)
+      }
     end
 
     def to_defined_value
@@ -2100,7 +2499,7 @@ module Cc1 #:nodoc:
     end
 
     def dup
-      MultipleValue.new(to_single_value.dup, nil)
+      MultipleValue.new(to_single_value.dup, nil, _base.tag.dup)
     end
 
     def effective_values
@@ -2111,19 +2510,21 @@ module Cc1 #:nodoc:
       if @descendants.empty?
         [self]
       else
-        @descendants.map { |multi_val| multi_val.descendants }.flatten.uniq
+        @descendants.map { |mval| mval.descendants }.flatten
       end
     end
 
-    protected
-    attr_reader :ancestor
+    def _base
+      # NOTE: This method will be invoked only from this file.
+      @base
+    end
   end
 
   class VersionedValue < MultipleValue
-    def initialize(orig_val)
+    def initialize(orig_val, tag)
       # NOTE: `orig_val.to_single_value' will be done in
       #       MultipleValue#initialize.
-      super(orig_val, nil)
+      super(orig_val, nil, tag)
 
       @version_controller = ValueVersionController.new(self)
     end
@@ -2157,14 +2558,14 @@ module Cc1 #:nodoc:
       delete_descendants!
       orig_val = @version_controller.original_value
       @version_controller = nil
-      _orig_overwrite!(orig_val)
+      _orig_overwrite!(orig_val, TransitionTag.new)
       @version_controller = ValueVersionController.new(self)
       invalidate_memo!
     end
 
     alias :_orig_overwrite! :overwrite!
 
-    def overwrite!(val)
+    def overwrite!(val, tag)
       @version_controller.fork_current_version
       super
       @version_controller.mark_current_versioning_group_as_sticky
@@ -2173,9 +2574,9 @@ module Cc1 #:nodoc:
 
     def force_overwrite!(val)
       # NOTE: This method will be invoked only from VariableTable#define.
-      single_val = val.to_single_value
-      @version_controller.original_value.overwrite!(single_val)
-      _orig_overwrite!(single_val)
+      sval = val.to_single_value
+      @version_controller.original_value.overwrite!(sval, nil)
+      _orig_overwrite!(sval, nil)
       invalidate_memo!
     end
 
@@ -2188,6 +2589,7 @@ module Cc1 #:nodoc:
     def widen_domain!(op, ope_val)
       @version_controller.fork_current_version
       super
+      @version_controller.mark_current_versioning_group_as_sticky
       invalidate_memo!
     end
 
@@ -2198,7 +2600,7 @@ module Cc1 #:nodoc:
     end
 
     def coerce_to(type)
-      VersionedValue.new(to_single_value.coerce_to(type))
+      VersionedValue.new(to_single_value.coerce_to(type), _base.tag.dup)
     end
 
     def effective_values
@@ -2213,8 +2615,8 @@ module Cc1 #:nodoc:
 
     private
     def compact_descendants!
-      @descendants = @version_controller.current_values.reject { |multi_val|
-        multi_val.equal?(self)
+      @descendants = @version_controller.current_values.reject { |mval|
+        mval.equal?(self)
       }.uniq
     end
   end
@@ -2262,17 +2664,15 @@ module Cc1 #:nodoc:
         initial_vals = current_version.initial_values
         current_versioning_group.delete_current_version_completely
         base_vals = current_versioning_group.base_values
-        base_vals.zip(initial_vals).each do |multi_val, initial_val|
-          multi_val.rollback! if forked
-          multi_val.overwrite!(initial_val) if initial_val
+        base_vals.zip(initial_vals).each do |mval, init_val|
+          mval.rollback! if forked
+          mval.overwrite!(init_val, TransitionTag.new) if init_val
         end
         begin_forking
       else
         current_versioning_group.delete_current_version
         if forked
-          current_versioning_group.base_values.each do |multi_val|
-            multi_val.rollback!
-          end
+          current_versioning_group.base_values.each { |mval| mval.rollback! }
         end
       end
 
@@ -2290,16 +2690,10 @@ module Cc1 #:nodoc:
     end
 
     def copy_current_version
-      return unless current_versioning_group.sticky?
-
       # NOTE: This method must be called between ending of the forking section
       #       and ending of the versioning group.
-      current_values.each do |multi_val|
-        base_val = multi_val.base_value
-        already_exist = multi_val.descendants.any? { |desc_multi_val|
-          !desc_multi_val.equal?(multi_val) && desc_multi_val.eql?(base_val)
-        }
-        multi_val.fork unless already_exist
+      if current_versioning_group.sticky?
+        current_values.each { |mval| mval.fork }
       end
     end
 
@@ -2311,22 +2705,28 @@ module Cc1 #:nodoc:
       case
       when current_versioning_group.sticky?
         fork_all_versions
-        base_ver.values = base_ver.values.map { |base_multi_val|
-          base_multi_val.descendants
-        }.flatten.uniq
+        base_vals = base_ver.values.map { |mval| mval.descendants }.flatten
+        base_ver.values = base_vals.each_with_object({}) { |mval, hash|
+          if eql_mval = hash[mval]
+            eql_mval._base.tag.by = mval._base.tag.by + eql_mval._base.tag.by
+            eql_mval._base.tag.at = mval._base.tag.at + eql_mval._base.tag.at
+          else
+            hash[mval] = mval
+          end
+        }.keys
       when current_versioning_group.versions_forked?
         # NOTE: When versions in the current versioning group have been forked,
         #       base_version of the current versioning group has already been
         #       forked.  So, it is safe to overwrite the base_version's values
         #       with the current versioning group's initial snapshot values.
-        initial_vals = current_versioning_group.initial_values
-        vals = base_ver.values.zip(initial_vals)
-        vals.each do |base_multi_val, initial_single_val|
-          base_multi_val.delete_descendants!
-          if base_multi_val.kind_of?(VersionedValue)
-            base_multi_val._orig_overwrite!(initial_single_val)
+        init_vals = current_versioning_group.initial_values
+        vals = base_ver.values.zip(init_vals)
+        vals.each do |base_mval, init_sval|
+          base_mval.delete_descendants!
+          if base_mval.kind_of?(VersionedValue)
+            base_mval._orig_overwrite!(init_sval, TransitionTag.new)
           else
-            base_multi_val.overwrite!(initial_single_val)
+            base_mval.overwrite!(init_sval, TransitionTag.new)
           end
         end
       else
@@ -2365,11 +2765,8 @@ module Cc1 #:nodoc:
       def initialize(base_ver, sticky = false)
         @base_version = base_ver
         @sticky = sticky
-
-        @initial_values = base_ver.values.map { |multi_val|
-          multi_val.base_value.dup
-        }
-        @version_stack = []
+        @initial_values = base_ver.values.map { |mval| mval._base.value.dup }
+        @current_version = nil
         @all_versions = []
       end
 
@@ -2390,7 +2787,7 @@ module Cc1 #:nodoc:
       end
 
       def current_version
-        @version_stack.empty? ? @base_version : @version_stack.last
+        @current_version || @base_version
       end
 
       def current_values
@@ -2398,13 +2795,12 @@ module Cc1 #:nodoc:
       end
 
       def begin_new_version
-        new_ver = Version.new(base_values)
-        @version_stack.push(new_ver)
-        @all_versions.push(new_ver)
+        @current_version = Version.new(base_values)
+        @all_versions.push(@current_version)
       end
 
       def end_current_version
-        @version_stack.pop
+        @current_version = nil
       end
 
       def delete_current_version_completely
@@ -2453,7 +2849,7 @@ module Cc1 #:nodoc:
 
       def fork_from(base_ver)
         if forking?
-          @values = base_ver.values.map { |multi_val| multi_val.fork }
+          @values = base_ver.values.map { |mval| mval.fork }
           @initial_values = @values.each_with_object([]) { |val, ary|
             ary.push(val.to_single_value.dup)
           }