adlint 3.0.10 → 3.2.0

data/lib/adlint/cc1/object.rb

@@ -242,13 +242,13 @@ module Cc1 #:nodoc:
       binding.memory.read
     end
 
-    def assign!(val)
+    def assign!(val, src = nil, br = nil)
       # NOTE: Length of the incomplete array type should be deducted while
       #       initializer evaluation.  So, adjustment of the assigning value
       #       can be done at this point by Value#coerce_to(type).
       # NOTE: Domain of the assigning value must be narrowed before writing to
       #       the memory by Value#coerce_to(type).
-      binding.memory.write(val.coerce_to(type))
+      binding.memory.write(val.coerce_to(type), src, br)
     end
 
     def uninitialize!
@@ -261,7 +261,7 @@ module Cc1 #:nodoc:
       self.value.narrow_domain!(op, val.coerce_to(type))
       # NOTE: Write via memory to correctly propagate inner variable's
       #       mutation to its outer variable.
-      binding.memory._cascade_update
+      binding.memory._cascade_update(nil, nil)
 
       self.value.exist?
     end
@@ -272,7 +272,7 @@ module Cc1 #:nodoc:
       self.value.widen_domain!(op, val.coerce_to(type))
       # NOTE: Write via memory to correctly propagate inner variable's
       #       mutation to its outer variable.
-      binding.memory._cascade_update
+      binding.memory._cascade_update(nil, nil)
 
       self.value.exist?
     end
@@ -343,15 +343,15 @@ module Cc1 #:nodoc:
 
     attr_reader :representative_element
 
-    def assign!(val)
+    def assign!(val, src = nil, br = nil)
       super
       if @representative_element
-        repr_type = @representative_element.type
         if val.undefined?
-          @representative_element.assign!(repr_type.undefined_value)
+          repr_val = @representative_element.type.undefined_value
         else
-          @representative_element.assign!(repr_type.arbitrary_value)
+          repr_val = @representative_element.type.arbitrary_value
         end
+        @representative_element.assign!(repr_val, src, br)
       end
     end
 
@@ -535,6 +535,7 @@ module Cc1 #:nodoc:
     end
 
     Summary = Struct.new(:object_id, :name, :type, :memory)
+    private_constant :Summary
   end
 
   class TemporaryVariable < OuterVariable
@@ -559,6 +560,7 @@ module Cc1 #:nodoc:
     end
 
     Summary = Struct.new(:object_id, :type, :memory)
+    private_constant :Summary
   end
 
   class InnerVariable < OuterVariable
@@ -686,18 +688,18 @@ module Cc1 #:nodoc:
       rollback_all_global_variables_value! if current_scope.global?
     end
 
-    def declare(dcl)
+    def declare(dcl, br)
       if var = lookup(dcl.identifier.value)
         var.declarations_and_definitions.push(dcl)
         return var
       end
 
       # NOTE: External variable may have undefined values.
-      define_variable(dcl, dcl.type, allocate_memory(dcl),
+      define_variable(dcl, br, dcl.type, allocate_memory(dcl),
                       dcl.type.undefined_value)
     end
 
-    def define(dcl_or_def, init_val = nil)
+    def define(dcl_or_def, br, init_val = nil)
       if storage_duration_of(dcl_or_def) == :static && !dcl_or_def.type.const?
         # NOTE: Value of the inconstant static duration variable should be
         #       arbitrary because execution of its accessors are out of order.
@@ -720,7 +722,7 @@ module Cc1 #:nodoc:
 
       # NOTE: Domain of the init-value will be restricted by type's min-max in
       #       define_variable.
-      define_variable(dcl_or_def, dcl_or_def.type,
+      define_variable(dcl_or_def, br, dcl_or_def.type,
                       allocate_memory(dcl_or_def), init_val)
     end
 
@@ -729,7 +731,7 @@ module Cc1 #:nodoc:
 
       # NOTE: Domain of the init-value will be restricted by type's min-max in
       #       define_variable.
-      define_variable(nil, type, mem, init_val)
+      define_variable(nil, nil, type, mem, init_val)
     end
 
     def lookup(name_str)
@@ -834,9 +836,9 @@ module Cc1 #:nodoc:
     end
 
     private
-    def define_variable(dcl_or_def, type, mem, init_val)
+    def define_variable(dcl_or_def, br, type, mem, init_val)
       var = create_variable(dcl_or_def, type, mem)
-      var.assign!(init_val)
+      var.assign!(init_val, dcl_or_def, br)
 
       if var.named?
         @named_variables.last[var.name] = var
@@ -929,8 +931,8 @@ module Cc1 #:nodoc:
       if type.return_type.function?
         interp.create_tmpvar
       else
-        retn_type = type.return_type
-        interp.create_tmpvar(retn_type, retn_type.return_value)
+        ret_type = type.return_type
+        interp.create_tmpvar(ret_type, ret_type.return_value)
       end
     end
 
@@ -994,7 +996,8 @@ module Cc1 #:nodoc:
           sink = arg
         end
 
-        sink.assign!(sink.type.return_value)
+        ret_val = sink.type.return_value
+        sink.assign!(ret_val, funcall_expr, interp.current_branch)
         interp.notify_variable_value_updated(expr, sink)
 
         # NOTE: Returning a value via a pointer parameter can be considered as
@@ -1173,15 +1176,15 @@ module Cc1 #:nodoc:
       @value
     end
 
-    def write(val)
+    def write(val, src, br)
       if @value
-        @value.overwrite!(val)
+        @value.overwrite!(val, TransitionTag.new([src], [br]))
       else
-        @value = VersionedValue.new(val)
+        @value = VersionedValue.new(val, TransitionTag.new([src], [br]))
       end
     end
 
-    def _cascade_update
+    def _cascade_update(src, br)
       # NOTE: This method will be called only from # #narrow_value_domain! and
       #       #widen_value_domain! of Variable to propagate memory mutation to
       #       the upper MemoryBlock from MemoryWindow.
@@ -1210,12 +1213,12 @@ module Cc1 #:nodoc:
     end
 
     alias :_orig_write :write
-    def write(val)
+    def write(val, src, br)
       super
       if !@windows.empty? and
           @value.array? && val.array? or @value.composite? && val.composite?
         @windows.zip(val.to_single_value.values).each do |win, inner_val|
-          win.write(inner_val, false)
+          win.write(inner_val, src, br, false)
         end
       end
     end
@@ -1239,12 +1242,12 @@ module Cc1 #:nodoc:
     end
 
     private
-    def handle_written_through_window(win)
+    def handle_written_through_window(win, src, br)
       if val = create_value_from_windows
-        unless win.read.must_be_undefined?
+        unless win.read.test_must_be_undefined.true?
           val = val.to_defined_value
         end
-        _orig_write(val)
+        _orig_write(val, src, br)
       end
     end
   end
@@ -1267,19 +1270,19 @@ module Cc1 #:nodoc:
       @owner.dynamic?
     end
 
-    def write(val, cascade = true)
-      super(val)
-      _cascade_update if cascade
+    def write(val, src, br, cascade = true)
+      super(val, src, br)
+      _cascade_update(src, br) if cascade
     end
 
-    def _cascade_update
-      on_written.invoke(self)
+    def _cascade_update(src, br)
+      on_written.invoke(self, src, br)
     end
 
     private
-    def handle_written_through_window(*)
+    def handle_written_through_window(win, src, br)
       super
-      _cascade_update
+      _cascade_update(src, br)
     end
   end
 

data/lib/adlint/cc1/trace.rb

@@ -0,0 +1,287 @@
+# Context tracer.
+#
+# Author::    Yutaka Yanoh <mailto:yanoh@users.sourceforge.net>
+# Copyright:: Copyright (C) 2010-2013, OGIS-RI Co.,Ltd.
+# License::   GPLv3+: GNU General Public License version 3 or later
+#
+# Owner::     Yutaka Yanoh <mailto:yanoh@users.sourceforge.net>
+
+#--
+#     ___    ____  __    ___   _________
+#    /   |  / _  |/ /   / / | / /__  __/           Source Code Static Analyzer
+#   / /| | / / / / /   / /  |/ /  / /                   AdLint - Advanced Lint
+#  / __  |/ /_/ / /___/ / /|  /  / /
+# /_/  |_|_____/_____/_/_/ |_/  /_/   Copyright (C) 2010-2013, OGIS-RI Co.,Ltd.
+#
+# This file is part of AdLint.
+#
+# AdLint is free software: you can redistribute it and/or modify it under the
+# terms of the GNU General Public License as published by the Free Software
+# Foundation, either version 3 of the License, or (at your option) any later
+# version.
+#
+# AdLint is distributed in the hope that it will be useful, but WITHOUT ANY
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+# A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along with
+# AdLint.  If not, see <http://www.gnu.org/licenses/>.
+#
+#++
+
+require "adlint/cc1/branch"
+require "adlint/cc1/value"
+
+module AdLint #:nodoc:
+module Cc1 #:nodoc:
+
+  module ContextTracing
+    # NOTE: Host class of this module must respond to #positive_contribs and
+    #       #negative_contribs.
+    def traceable_positive_contribs
+      positive_contribs.select { |mval| mval.transition.last.tag.traceable? }
+    end
+
+    def traceable_negative_contribs
+      negative_contribs.select { |mval| mval.transition.last.tag.traceable? }
+    end
+
+    def sample_positive_transition
+      if contrib = traceable_positive_contribs.first
+        contrib.transition
+      else
+        nil
+      end
+    end
+  end
+
+  module NegativePathsTracing
+    include ContextTracing
+
+    def trace_negative_paths(report, loc, traced)
+      trans = traceable_negative_contribs.map { |mval| mval.transition }
+      branches = trans.map { |tr| tr.last.tag.at }.flatten
+      sorted_branches = sort_branches_by_groups(branches)
+      branches = branches.to_set
+
+      rch_groups = []
+      unr_groups = []
+
+      sorted_branches.each_key.with_object([]) { |gr, msgs|
+        case
+        when gr.branches_to_trunk.any? { |upper| branches.include?(upper) }
+          next
+        when gr.complete? && gr.branches.size == sorted_branches[gr].size
+          unr_groups.push(gr)
+        else
+          rch_groups.push(gr)
+          sorted_branches[gr].each do |br|
+            emit_negative_ctrlexpr(msgs, report, loc, traced, br.ctrlexpr)
+          end
+        end
+      } + emit_remaining_paths(report, loc, traced, rch_groups, unr_groups)
+    end
+
+    private
+    def emit_remaining_paths(report, loc, traced, rch_groups, unr_groups)
+      traced_groups = Set.new
+      rch_groups.each_with_object([]) { |gr, msgs|
+        cur_br = gr.trunk
+        while cur_br
+          emit_positive_ctrlexpr(msgs, report, loc, traced, cur_br.ctrlexpr)
+          traced_groups.add(cur_br.group)
+          cur_br = cur_br.trunk
+        end
+      } + unr_groups.each_with_object([]) { |gr, msgs|
+        cur_br = gr.trunk
+        while cur_br
+          unless traced_groups.include?(cur_br.group)
+            emit_negative_ctrlexpr(msgs, report, loc, traced, cur_br.ctrlexpr)
+            break
+          end
+          cur_br = cur_br.trunk
+        end
+      }
+    end
+
+    def sort_branches_by_groups(branches)
+      branches.each_with_object(Hash.new { |h, k| h[k] = [] }) do |br, groups|
+        groups[br.group].push(br)
+      end
+    end
+
+    def emit_positive_ctrlexpr(msgs, report, loc, traced, ctrlexpr)
+      if ctrlexpr and expr = ctrlexpr.to_expr
+        if expr.location && expr.location < loc && !traced.include?(expr)
+          msgs.push(report.C(:C1001, expr.location))
+          traced.add(expr)
+        end
+      end
+    end
+
+    def emit_negative_ctrlexpr(msgs, report, loc, traced, ctrlexpr)
+      if ctrlexpr and expr = ctrlexpr.to_expr
+        if expr.location && expr.location < loc && !traced.include?(expr)
+          msgs.push(report.C(:C1002, expr.location))
+          traced.add(expr)
+        end
+      end
+    end
+  end
+
+  module UndefinableContextTracing
+    include ContextTracing
+    include NegativePathsTracing
+
+    def emit_context_messages(report, loc)
+      traced = Set.new
+      msgs = trace_positive_paths(report, loc, traced) +
+             trace_negative_paths(report, loc, traced)
+
+      unless msgs.empty?
+        [report.C(:C1000, Location.new)] +
+          msgs.sort { |a, b| a.location <=> b.location }
+      else
+        []
+      end
+    end
+
+    private
+    def trace_positive_paths(report, loc, traced)
+      # TODO: Evidence of the test result might have two or more contributors.
+      #       All the evidences should be complemented by context messages?
+      unless pos_trans = sample_positive_transition
+        return []
+      end
+
+      pos_trans.each_with_object([]) do |ss, msgs|
+        if src = ss.tag.by.find { |node| node.kind_of?(VariableDefinition) }
+          if src.location && src.location < loc && !traced.include?(src)
+            if ss.value.test_may_be_undefined.true?
+              msgs.push(report.C(:C1003, src.location))
+              traced.add(src)
+            end
+          end
+        end
+      end
+    end
+
+    # NOTE: Mix-in this module to AdLint::Cc1::UndefinableTestEvidence.
+    UndefinableTestEvidence.class_eval { include UndefinableContextTracing }
+  end
+
+  module NullabilityContextTracing
+    include ContextTracing
+    include NegativePathsTracing
+
+    def emit_context_messages(report, loc)
+      traced = Set.new
+      msgs = trace_positive_paths(report, loc, traced) +
+             trace_negative_paths(report, loc, traced)
+
+      unless msgs.empty?
+        [report.C(:C1000, Location.new)] +
+          msgs.sort { |a, b| a.location <=> b.location }
+      else
+        []
+      end
+    end
+
+    private
+    def trace_positive_paths(report, loc, traced)
+      # TODO: Evidence of the test result might have two or more contributors.
+      #       All the evidences should be complemented by context messages?
+      unless pos_trans = sample_positive_transition
+        return []
+      end
+
+      pos_trans.each_with_object([]) do |ss, msgs|
+        branch = ss.tag.at.find { |br| br.ctrlexpr.to_expr }
+        while branch
+          if expr = branch.ctrlexpr.to_expr and
+              expr.location && expr.location < loc
+            unless traced.include?(expr)
+              msgs.push(report.C(:C1001, expr.location))
+              traced.add(expr)
+            end
+          end
+          branch = branch.trunk
+        end
+
+        src = ss.tag.by.find { |node|
+          node.location && node.location < loc && !traced.include?(node)
+        }
+        if src
+          case
+          when ss.value.test_must_be_null.true?
+            msgs.push(report.C(:C1004, src.location))
+            traced.add(src)
+          when ss.value.test_may_be_null.true?
+            msgs.push(report.C(:C1005, src.location))
+            traced.add(src)
+          end
+        end
+      end
+    end
+
+    # NOTE: Mix-in this module to AdLint::Cc1::NullabilityTestEvidence.
+    NullabilityTestEvidence.class_eval { include NullabilityContextTracing }
+  end
+
+  module DefinableContextTracing
+    # NOTE: Host class must have instance variable named @predicate.
+    attr_reader :predicate
+
+    include ContextTracing
+    include NegativePathsTracing
+
+    def emit_context_messages(report, loc)
+      traced = Set.new
+      msgs = trace_positive_paths(report, loc, traced) +
+             trace_negative_paths(report, loc, traced)
+
+      unless msgs.empty?
+        [report.C(:C1000, Location.new)] +
+          msgs.sort { |a, b| a.location <=> b.location }
+      else
+        []
+      end
+    end
+
+    private
+    def trace_positive_paths(report, loc, traced)
+      # TODO: Evidence of the test result might have two or more contributors.
+      #       All the evidences should be complemented by context messages?
+      unless pos_trans = sample_positive_transition
+        return []
+      end
+
+      pos_trans.each_with_object([]) do |ss, msgs|
+        branch = ss.tag.at.find { |br| br.ctrlexpr.to_expr }
+        while branch
+          if expr = branch.ctrlexpr.to_expr and
+              expr.location && expr.location < loc
+            unless traced.include?(expr)
+              msgs.push(report.C(:C1001, expr.location))
+              traced.add(expr)
+            end
+          end
+          branch = branch.trunk
+        end
+
+        src = ss.tag.by.find { |node|
+          node.location && node.location < loc && !traced.include?(node)
+        }
+        if src && predicate.call(ss.value)
+          msgs.push(report.C(:C1006, src.location))
+          traced.add(src)
+        end
+      end
+    end
+
+    # NOTE: Mix-in this module to AdLint::Cc1::DefinableTestEvidence.
+    DefinableTestEvidence.class_eval { include DefinableContextTracing }
+  end
+
+end
+end