sbuilder-ethereum 0.0.6

data/lib/sbuilder/sexp_processor_dataflow.rb

@@ -0,0 +1,461 @@
+
+require 'yaml'
+require 'tsort'
+
+module Sbuilder
+  module Ethereum
+
+
+# Assume
+# - symbols defined && resolved
+#   -- Scope#enclosing_scope set
+#   -- DeclRef#enclosingScope set
+#   -- DeclRef#declarationRef set
+#
+# Actions
+# - traverse AST and collect dataflow edges
+#   -- Identifier: exp - exp#declarationRef
+#   -- Assignment: exp.variable - exp.expression
+#   -- Return: exp.functionReturnList.parameters[] - exp.expressions[]
+# - identify domains
+#   --  use tsort#strongly_connected_components to identify
+#
+# Implementation uses +id+ -property assigned by solc compiler to
+# distinguish nodes in SexpAst -tree.
+
+class SexpProcessorDataflow < SexpProcessorEthereum
+
+  # @attr [Hash] dataflowEdges map SexpAst#id --> [SexpAst#id:Array]
+  attr_accessor :dataflowEdges
+
+  # @attr [Hash] dataflowNodes map SexpAst#id -> [SexpAst]
+  attr_accessor :dataflowNodes
+
+  # # @attr [Domains] domains
+  attr_accessor :domains
+  
+  # Map sexp_type to (priority, domain) to use SexpAst -node to give name 
+  SEXP_TYPE_2_PRIORITY = {
+    :ContractDefinition => ->(sexp) {
+      return 80, nil
+    },
+      :VariableDeclaration => ->(sexp) {
+        if sexp.typeSexp.sexp_type == :Domain
+          # has already been determined. e.g. adding common msg
+          # properties
+          return 100, sexp.typeSexp
+        elsif sexp.typeSexp.sexp_type == :UserDefinedTypeName && sexp.typeSexp.symbolTypeReference.sexp_type == :ContractDefinition
+          # pointing contract
+          return 100, Domain.s( Constants::DOMAIN_ADDRESS )            
+        else
+          case sexp.scopeDefining.sexp_type
+          when :ContractDefinition
+            return 80, nil
+            # return 100, Domain.s( Constants::DOMAIN_ADDRESS )            
+          when :ParameterList
+            return 35, nil
+          when :FunctionDefinition
+            return 40, nil
+          when :ParameterList
+            return 35, nil
+          else
+            raise SexpProcessorDataflowException.new "Unknown scope type '#{sexp.scopeDefining.sexp_type}' for #{sexp}" 
+          end
+        end
+      },
+      :Literal => ->(sexp) {
+        if sexp.type == Constants::SOL_BOOLEAN_TYPE
+          # Map boolean to fixed domain name
+          return 100, Domain.s( Constants::DOMAIN_BOOLEAN )
+        elsif sexp.type =~ /int_const /
+          # Integer const does identify domain - nor results to error
+          return nil, nil
+        else
+          raise SexpProcessorDataflowException.new "Unknown literal type  '#{sexp.type}' for #{sexp}" 
+        end
+      },            
+      :MemberAccess => ->(sexp) { return 30, nil },      
+      :Identifier => ->(sexp) { return 30, nil },
+      :IndexAccess => ->(sexp) {
+        # variable declartion of identifier must be 'Mapping', resolve
+        # to domain of 'mapping-function'
+        domainOfMapping = sexp.identifier.declationRef.typeSexp.mapTo.domainReference
+        return 100, sexp.identifier.declationRef.typeSexp.mapTo.domainReference unless domainOfMapping.nil?
+        return nil, nil
+      },
+      :ElementaryTypeName => ->(sexp) {
+        if sexp.typeName == Constants::SOL_ADDRESS
+          return 100, Domain.s( Constants::DOMAIN_ADDRESS )
+        elsif sexp.typeName == Constants::SOL_UINT
+          # uint value domain overridden by better candiadate
+          # (e.g. msg.value)
+          return 10, Domain.s( Constants::DOMAIN_DEFAULT )          
+        else
+          return nil, nil
+          # raise SexpProcessorDataflowException.new "Unknown elementary type name for #{sexp}"
+        end
+      },      
+      :FunctionCallReadReturn => ->(sexp) { return nil, nil },
+      :FunctionDefinition => ->(sexp) {
+        if sexp.returnList.parameters.length == 1 && sexp.returnList.parameters[0].type  == Constants::DOMAIN_BOOLEAN
+          return 100, Domain.s( Constants::DOMAIN_BOOLEAN )
+        elsif sexp.returnList.parameters.length == 1 && sexp.returnList.parameters[0].type  == Constants::SOL_BOOLEAN_TYPE
+          return 100, Domain.s( Constants::DOMAIN_BOOLEAN )
+        elsif sexp.returnList.parameters.length == 0
+          return 100, Domain.s( Constants::DOMAIN_BOOLEAN )          
+        else
+          raise SexpProcessorDataflowException.new "Unknown function return type  '#{sexp.returnList}' for #{sexp}"
+        end
+      },      
+      :BinaryOperation => ->(sexp) { return nil, nil },            
+    }
+  
+  
+
+  # ------------------------------------------------------------------
+  # @!group Construct & configure
+  
+  def initialize( options={} )
+    
+    super( options )
+
+    # see addEdge to populate
+    self.dataflowEdges = THash.new
+    self.dataflowNodes = {}    
+  end
+  
+  # @!endgroup
+
+  # ------------------------------------------------------------------
+  # @!group scope support
+
+  # @attr [VariableDeclaration] currentDecl
+  attr_accessor :currentDecl
+
+  def varDecled( expDecl )
+    prevDecl = currentDecl
+    self.currentDecl = expDecl
+    begin
+      yield
+    ensure
+      self.currentDecl = prevDecl
+    end
+
+  end
+
+  # @!endgroup
+  
+  
+  # ------------------------------------------------------------------
+  # @!group Entry point & return the identified domains
+
+  # private def processGlobals( exp )
+  #   return if @processGlobals
+
+  #   # identify data flows in function global
+  #   exp.globalScope.symbolDefinitions.
+  #     select { |globalExp| globalExp.sexp_type == :FunctionDefinition }.
+  #     each { |expFunction| process_rest( expFunction ) }
+
+  #   @processGlobals = true
+        
+  # end
+  # 
+  #
+  # @return [Domains] domains Sexp, with domain -property
+  def process_SourceUnit( exp )
+    
+    logger.debug "#{__method__}: starting with '#{exp}" if logger.debug?
+
+    # traverse tree collect 'dataflowEdges', 'dataflowNodes'
+    process_rest( exp  )
+
+    analyzeDomains    
+
+  end
+
+  def process_GlobalScope( exp )
+    logger.debug "#{__method__}: exp=#{exp}" if logger.debug?
+    # identify data flows in function global
+    # exp.globalScope.symbolDefinitions.
+    #   select { |globalExp| globalExp.sexp_type == :FunctionDefinition }.
+    #   each { |expFunction| process_rest( expFunction ) }
+
+    # traverse tree collect 'dataflowEdges', 'dataflowNodes'
+    process_rest( exp  )
+
+    analyzeDomains    
+
+  end
+
+  ##
+  # Cm
+  private def analyzeDomains
+    # Identify domains after tree traversal
+
+    # identify strongly connected components in 'dataflowEdges'
+    strong_components = find_strong_components()
+    logger.debug "#{__method__}: strong_components: #{strong_components}" if logger.debug?
+
+    # for each 'strong_component' find representative sexp to generate
+    # name for the domain
+    domainsIdentified=[]
+    strong_components.each do |strong_component|
+      
+      # find SexpAst -node to give name for the domain
+      strong_component_name_sexp = find_representative_name_sexp( strong_component )
+
+      # Create Domain with +domainName+
+      domain = Domain.new( domainName(strong_component_name_sexp) )
+      logger.info "#{__method__}: identified domain #{domain}"
+      domainsIdentified <<  domain
+
+      # update pointer to domain on sexp node
+      update_domain_on_sexps( domain, strong_component )
+
+    end
+    
+    # Sexp with collection of domains
+    self.domains = Domains.new( domainsIdentified )
+    
+    logger.info "#{__method__}: analyzed domains='#{domains}"
+    domains
+
+    
+  end
+  
+  
+
+  # @!endgroup
+  
+  # ------------------------------------------------------------------
+  # @!group Collect dataflow edges
+
+
+  def process_ContractDefinition( exp )
+    logger.debug  "#{__method__}: exp=#{exp}" if logger.debug?
+
+    # # Add globals also domain analysis
+    # processGlobals( exp )
+    
+    # add a domain  to configure number of contracts
+    addEdge( exp.sexp_type, exp, nil )
+    process_rest( exp  )
+
+  end
+
+  def process_VariableDeclaration( exp )
+    logger.debug  "#{__method__}: exp=#{exp}" if logger.debug?
+    
+    # declaration is part of its own strong component 
+    addEdge( exp.sexp_type, exp, exp ) unless exp.isMapping
+    varDecled( exp ) do 
+      process_rest( exp )
+    end
+    s()
+  end
+
+  def process_ElementaryTypeName( exp )
+    logger.debug  "#{__method__}: exp=#{exp}" if logger.debug?
+    
+    # non elemenary declaration
+    if currentDecl && currentDecl.isMapping 
+      logger.info "#{__method__} compposite #{currentDecl.name} for #{exp}"
+      addEdge( exp.sexp_type, exp, exp )
+    end
+    s()
+  end
+
+  def process_MemberAccess( exp )
+    logger.debug  "#{__method__}: exp=#{exp}" if logger.debug?
+    if exp.isFunctionOnFunction
+      # AST in 'function on function' case, e.g. demo1.set.value(20)(
+      # 6 ) like s(:MemberAccess, "value", s(:MemberAccess, "set",
+      # s(:Identifier, "contract Demo1", "demo1")))
+      #
+      # we are processing s(:MemberAccess, "value", just recurse
+      process_rest( exp )
+    else
+      raise  SexpProcessorDataflowException.new "Missing declationRef in #{exp}" unless exp.isDeclarationRef && !exp.declationRef.nil?
+      addEdge( exp.sexp_type, exp, exp.declationRef )
+    end
+    s()
+  end
+
+  def process_Identifier( exp )
+    logger.debug  "#{__method__}: exp=#{exp}" if logger.debug?
+    raise  SexpProcessorDataflowException.new "Missing declationRef in #{exp}" unless exp.isDeclarationRef && !exp.declationRef.nil?
+    addEdge( exp.sexp_type, exp, exp.declationRef )
+    process_rest( exp  )             
+  end
+
+  def process_Assignment( exp )
+    logger.debug  "#{__method__}: exp=#{exp}" if logger.debug?
+
+    addEdge( exp.sexp_type, exp.lval, exp.rval )
+    process_rest( exp  )             
+  end
+
+  def process_Return( exp )
+    logger.debug  "#{__method__}: exp=#{exp}" if logger.debug?
+    logger.debug  "#{__method__}, exp.functionReturnList=#{exp.functionReturnList}" if logger.debug?   
+
+    # iterate each return expression/output parameter mapping
+    exp.functionReturnList.parameters.each_with_index do |parameter,i|
+      logger.debug  "#{__method__}, parameter[#{i}]=#{parameter}" if logger.debug?
+      addEdge( exp.sexp_type, parameter, exp.expressions[i] )
+    end
+      
+    process_rest( exp  )             
+  end
+  
+  
+
+  # @!endgroup
+  # ------------------------------------------------------------------
+  # @!group Methods to build edges
+
+  # Add bidirectional edge '+sexp1+ --- +sexp2+' to +dataflowEdges+
+  # when processing +sexp_type+ node. If +sexp2+ is nil add just node.
+  #
+  # @param [SexpAst|nil] sexp1 data flown between +sexp1+ - +sexp2+,
+  #
+  # @param [SexpAst|nil] sexp2 may be nil, in which case add just node +sexp1+
+  #
+  private def addEdge( sexp_type, sexp1, sexp2 )
+    logger.debug "#{__method__}: '#{sexp1.id}:#{sexp1} --- #{sexp2.nil? ? 'nil' : sexp2.id}:#{sexp2}' for process_#{sexp_type}" if logger.debug?
+
+    # make sura that the nodes are there
+    addNode( sexp1 )
+    addNode( sexp2 )  unless  sexp2.nil?
+    
+    # ensure key known
+    self.dataflowEdges[sexp1.id] = [] unless dataflowEdges.key?(sexp1.id)
+    self.dataflowEdges[sexp2.id] = [] unless sexp2.nil? || dataflowEdges.key?(sexp2.id) 
+
+    # add to directional edges - unless either node nil, or it is
+    # already there
+    if sexp1 && sexp2 then
+      self.dataflowEdges[sexp1.id] << sexp2.id unless dataflowEdges[sexp1.id].include?( sexp2.id ) 
+      self.dataflowEdges[sexp2.id] << sexp1.id unless dataflowEdges[sexp2.id].include?( sexp1.id )
+    end
+    
+  end
+
+  
+  private def addNode( sexp )
+    self.dataflowNodes[sexp.id] = sexp unless dataflowNodes.key?(sexp.id)
+  end
+
+  # @!endgroup
+
+  # ------------------------------------------------------------------
+  # @!group Propage domain information
+
+  
+
+  private def update_domain_on_sexps( domain, strong_component )
+
+    strong_component.each do |sexpAstId|
+
+      sexp_node = dataflowNodes[sexpAstId]
+      
+      # should mix DomainRef
+      sexp_node.domainReference = domain
+      logger.info "#{__method__}:  --> set domain:  domain=#{domain} ->  #{sexp_node[0]},#{sexp_node[1]}"
+      logger.debug "#{__method__}: set domain:  domain=#{domain} in full  #{sexp_node}" if logger.debug?
+    end
+    
+    
+  end
+  
+  # @!endgroup
+  
+  # ------------------------------------------------------------------
+  # @!group Helper class to implement tsort#strongly_connected_components
+  
+
+  class THash < Hash
+
+    include TSort
+
+    # methods used by tsort
+    alias tsort_each_node each_key
+    def tsort_each_child(node, &block)
+      fetch(node).each(&block)
+    end    
+  end
+
+  # @return [Array] strong_components
+  
+  private def find_strong_components
+    dataflowEdges.strongly_connected_components
+  end
+
+  # @!endgroup
+
+  # ------------------------------------------------------------------
+  # @!group Use strong components to define domain
+
+  # Identify SexpAst -node among +strong_component+ array, which gives
+  # name for the domain.
+  #
+  # @param [Id:Array] strong_component array of SexpAst#id values mapping to 'dataflowNodes'
+  #
+  # @return [SexpAst] name_sexp used to generate name for the domain entry
+  #
+  private def find_representative_name_sexp( strong_component )
+    # 
+    name_sexp_priority=0
+    name_sexp = nil
+    if logger.debug?
+      logger.debug "#{__method__}: strong_component=#{strong_component.map { |sexpAstId | dataflowNodes[sexpAstId].inspect }.join(';')}" if logger.debug?
+    end
+    strong_component.each do |sexpAstId|
+      sexp_type = dataflowNodes[sexpAstId].sexp_type
+      sexp_node = dataflowNodes[sexpAstId]
+      logger.debug "Lookup in SEXP_TYPE_2_PRIORITY  #{dataflowNodes[sexpAstId]}" if logger.debug?
+      raise "Missing implementation in SEXP_TYPE_2_PRIORITY for #{sexp_type}(is symbol or string?= #{sexp_type.class}) for #{sexp_node}" unless SEXP_TYPE_2_PRIORITY.key?(sexp_type)
+      # Use lambda to callucate priority
+      priority, domain_sexp  = SEXP_TYPE_2_PRIORITY[sexp_type].call( sexp_node )
+      logger.debug "#{__method__}: id=#{sexpAstId}->#{sexp_type}->#{priority}, node=#{sexp_node}" if logger.debug?
+      # better name candiate found
+      if domain_sexp
+        # lambda new it best
+        name_sexp, name_sexp_priority = domain_sexp, priority if !priority.nil? && (priority > name_sexp_priority)
+      else
+        name_sexp, name_sexp_priority = dataflowNodes[sexpAstId], priority if !priority.nil? && (priority > name_sexp_priority)
+      end
+    end
+
+    raise  SexpProcessorDataflowException.new "Could not find domain for components #{strong_component.nil? ? 'nil' : strong_component.map{ |c| dataflowNodes[c].to_s }.join(',')}" if name_sexp.nil?
+
+    logger.info "#{__method__}: name_sexp=#{name_sexp} for strong_component=#{strong_component.map { |sexpAstId | dataflowNodes[sexpAstId].inspect }.join(';')}"
+
+    name_sexp
+  end
+
+  # @param [SexpAst] name_sexp used to generate name for the domain entry
+  #
+  # @return [String] domainName to use for domain
+  private def domainName( name_sexp )
+    case name_sexp.sexp_type
+    when :VariableDeclaration
+      "#{ name_sexp.scopeDefining.name}_#{name_sexp.name}"
+    when :ContractDefinition
+      "#{name_sexp.name}"
+    when :Domain
+      "#{name_sexp.name}"
+    else
+      raise  SexpProcessorDataflowException.new "Do not know how to create name for '#{name_sexp.sexp_type}' for #{name_sexp}"
+    end
+  end
+  
+  # @!endgroup    
+end # class
+
+
+
+  end
+end
+