sbuilder-eth 0.0.4

data/lib/eth/ethereum_expression.rb

@@ -0,0 +1,476 @@
+# coding: utf-8
+module Sbuilder
+
+  module Eth
+
+    # Module to include to Ethreum class containing methods to
+    # translate Solidity expression to Al language expressions.
+    module EthereumExpression
+
+      # ------------------------------------------------------------------
+      # @!group Distpath reference to lvalue 
+
+      # @!endgroup
+
+      
+      # Dispatch lval reference based lval AST node sexp_type.
+      #
+      # @return [TlaSexp] :Identifier -> name (='value' attribute),
+      # :IndexAccess => [ raise TODO ]
+      def lvalAccessDistpatcher
+        @lvalAccessDistpatched || {
+          :Identifier => ->(identifierAst) { identifierAst['value'] },
+          :IndexAccess => ->(indexAccessAst) do
+            #intetifierAst = indexAccessAst.identifier
+            indexerAst = indexAccessAst.indexer
+            indexer = Ethereum.dispatcher( expressionDispatcher, indexerAst.sexp_type, indexerAst)
+            alApi.tlaRecordIndex(indexAccessAst.identifier['value'], indexer )
+          end,
+        }
+      end
+
+      # ------------------------------------------------------------------
+      # @!group Expression translation
+
+      # Translate 'expressionAst' using {#expressionDispatcher}.
+      #
+      # @return [Al::Expression] trasnalation of 'expressionAst'
+      #
+      def dispatchExpression( expressionAst ) # 
+        @logger.debug( "#{__method__}: expressionAst=#{expressionAst}" ) if @logger.debug?
+        Ethereum.dispatcher( expressionDispatcher, expressionAst.sexp_type, expressionAst)
+      end
+
+      # Dispatch tranlation for Solidity AST expression based
+      # sexp_type of expression sexp_type.
+      #
+      #
+      # @return [Hash] :sexp_type => lambda(AstSexp) to tranlate
+      #          Solidity AST node to AL language expression
+      def expressionDispatcher
+        @expressionDispatcher ||= {
+          :ExpressionContext => ->(contextAst) do
+            # dispatch again using sexp_type of the wrapped expressionAst
+            Ethereum.dispatcher( expressionDispatcher, contextAst.expressionAst.sexp_type, contextAst)
+          end,
+          :BinaryOperation => method(:binaryExpr),
+          :Literal => method(:constantExpr),
+          :FunctionCall => method(:functionResponseExpr),
+          :Identifier => method(:identifierExpr),
+          :MemberAccess => method( :memberAccessExpr),
+          :IndexAccess => method( :indexAccessExpr ),
+          :TupleExpression => method( :tupleExpression ),
+        }
+      end
+
+      # Translate expression for 'functionCall' to read operator call
+      # reading function response, and accessing return value.
+      #
+      # Assume: pre-processor has added function call just prior to
+      # the statement accessing function response value)
+      #
+      # TODO: should add support to manage tuple return values from
+      # function call
+      #
+      # @param ast [ExpressionContext,:FunctionCall] function call (or
+      #        function wrapped into context) to create expression to
+      #        access response from function call
+      
+      def functionResponseExpr( ast )
+        @logger.info "#{__method__}: ast=#{ast}" if @logger.debug?
+
+        if ast.sexp_type == :ExpressionContext
+          functionCallStmt = ast.expressionAst
+        else
+          functionCallStmt = ast
+        end
+
+
+        # call target
+        functionCalled = functionCallStmt.callTarget # functionCallStmt.functionCalled.reference
+        contractCalled = functionCalled.enclosingScope
+        @logger.info "#{__method__} called= #{contractCalled['name']}(#{functionCalled['name']})"
+
+        # TODO: add suppport for tuples
+        if ( functionCallStmt.isConstructorCall )
+          # contrcutors return addres
+          returnParameter = Constants::FIELD_NAME_ADDRESS
+        else
+          # normal function
+          raise MissingImplementation, "Support only 1 return value, called f with #{functionCalled.responseParameters.parameters.length} params" if functionCalled.responseParameters.parameters.length != 1
+          returnParameter = functionCalled.responseParameters.parameters[0]['name']
+        end
+        
+        # access return variable in function response
+        alApi.tlaRecordField(
+          alApi.tlaOperatorCall(alApi.tlaPlainname(Constants::SBUILDER_GET_RESPONSE), [exprInterfaceOperation(contractCalled['name'], functionCalled['name'])]),
+          returnParameter
+        )
+        
+      end
+      
+
+      # Translate tupleExpression by translating each tuple element
+      # indididually with {#dispatchExpression}.
+      #
+      # @return [Array<AlExpression>] array of translated expressions
+      #   
+      def tupleExpression( tupleAst )
+
+        @logger.info "#{__method__}: proces tuple with #{tupleAst.children.length} elements"
+        tupleAst.children.map do |tupleElement|
+          dispatchExpression( tupleElement )
+        end
+          
+      end
+      
+
+      # Translate Solidity AST node of type :BinaryOperation to
+      # al-binary expression. Left hand side and right hand side
+      # expresions are dispatched using {#expressionDispatcher}, and
+      # operator translated using {#binaryOperator}. Evaluate in
+      # {ExpressionContext}, if 'ast' is defined within
+      # {ExpressionContext}.
+      #
+      # @param ast [ExpressionContext,Identifier] identifier (or
+      #        identifier wrapped in context) to create expression for.
+      #
+      def binaryExpr( ast )
+
+        if ast.sexp_type == :ExpressionContext
+
+          # Evaluate lval and rval in ExpressionContext
+          lExpr = Ethereum.dispatcher( expressionDispatcher,
+                             ast.expressionAst.children[0].sexp_type,
+                             ExpressionContext.createExpressionContext( ast.expressionAst.children[0], ast.context )
+                           )
+          rExpr = Ethereum.dispatcher( expressionDispatcher,
+                             ast.expressionAst.children[1].sexp_type,
+                             ExpressionContext.createExpressionContext( ast.expressionAst.children[1], ast.context )
+                           )
+          operator = ast.expressionAst['operator']          
+          
+        else
+          # No context given - extract element of bin expression
+          lExpr =  Ethereum.dispatcher( expressionDispatcher,
+                              ast.children[0].sexp_type,
+                              ast.children[0]
+                           )
+          operator = ast['operator']
+          rExpr =  Ethereum.dispatcher( expressionDispatcher,
+                              ast.children[1].sexp_type,
+                              ast.children[1]
+                            )
+        end
+
+        alApi.binaryExpression do
+          lval lExpr
+          op binaryOperator(operator)
+          rval rExpr
+        end
+        
+          
+      end
+
+      # Translate 'solidityOperator' to 'alOperator. Raise
+      # {#MissingImplementation} if no translation found.
+      def binaryOperator( solidityOperator  )
+        # TODO : map to AL-constants
+        solidityOperators = {
+          "*" => :mult,
+          "+" => :plus,
+          "-" => :minus,
+          "&&" => :and,
+          "||" => :or,
+          "==" => :equal,
+          "!=" => :unequal,
+          ">=" => :ge,
+          ">" => :gt,                             
+          "<" => :lt,                             
+          "<=" => :le,                             
+        }
+        alOperator = solidityOperators[solidityOperator]
+        raise MissingImplementation, "Unknown solidity operator #{solidityOperator} - known Solidity operators #{solidityOperators.keys.join(',')}" if alOperator.nil?
+        alOperator
+      end
+      
+
+      # Translate Solidity :Literal to AL Constant
+      # expression. Translation inspects AST 'type' attribute to
+      # choose correct intepration for AST 'value' attribute.
+      #
+      # @param ast [ExpressionContext,Constant] constant (or constant
+      #        wrapped in context) to create expression for.
+      #
+      #
+      def constantExpr( ast )
+        
+        # Context does no impact constant trasnlation
+        if ast.sexp_type == :ExpressionContext
+          constantAst = ast.expressionAst
+        else
+          constantAst = ast
+        end
+
+        case constantAst.attribute("type")
+        when /^literal_string/
+          alApi.constantExpression do
+            value constantAst.attribute('value')
+          end
+        when /^int_const */
+          alApi.constantExpression do
+            value constantAst.attribute('value').to_i
+          end
+        when /^bool/
+          alApi.constantExpression do
+            value constantAst.attribute('value') == "true"
+          end
+        else
+          raise TranslatorException, "Missing implementation for constant  expression type '#{constantAst.attribute('type')}' in #{constantAst}"          
+        end
+      end
+
+      # Create expression to access member in an identifier.
+      #
+      # Implementation find path for member variables, and creates an
+      # {#identifierExpression}. expression to access member of the
+      # identifier of 'memberAccessAst'
+      #
+      # @param ast [ExpressionContext,MemberAccess] MemberAccess (or
+      #        MemberAccess wrapped in context) to create expression
+      #        for.
+      #
+      def memberAccessExpr( ast )
+        @logger.debug "#{__method__}: ast=#{ast}" if @logger.debug?
+
+        if ast.sexp_type == :ExpressionContext
+          memberAccessAst = ast.expressionAst
+          # Evaluate idExpression within context
+          idExpression = Ethereum.dispatcher( expressionDispatcher,
+                                     ast.expressionAst.identifierAst.sexp_type,
+                                     ExpressionContext.createExpressionContext( ast.expressionAst.identifierAst, ast.context )
+                           )
+          
+        else
+          memberAccessAst = ast
+          # Create id expression
+          idExpression = Ethereum.dispatcher( expressionDispatcher,
+                                     ast.identifierAst.sexp_type,
+                                     ast.identifierAst )
+          
+        end
+
+        @logger.debug "#{__method__}: memberAccessAst.member=#{memberAccessAst.memberName}, idExpression=#{idExpression}" if @logger.debug?
+        # Translation to 'idExpression.member'
+        alApi.tlaRecordField( idExpression,  memberAccessAst.memberName )
+        
+      end
+
+      
+      # Create expression for Solidity identifier. Evaluate identifier
+      # in 3 cases 1) in existing contract context (e.g. assign
+      # statement) 2) in context (but not for contract) 3) without
+      # context.
+      #
+      # Expression identifier may be available in execution context,
+      # for example in TLA action updating contract variable uses set
+      # operation and an iteration variable for contracts. In this
+      # case, reference to a contract should be resolved to set
+      # iteration variable.
+      #
+      #
+      #
+      # @param ast [ExpressionContext,Identifier] identifier (or
+      #        identifier wrapped in context) to create expression for.
+      #
+      # @return [Al::Expression] 1) Al expression such as 'a.idName'
+      #          if ast.sexp_type == :ExpressionContext && context for
+      #          scope of variable declation found in context. 2)
+      #          create expression using {#identifierReference} - else
+      def identifierExpr( ast )
+        @logger.debug "#{__method__}: ast=#{ast}" if @logger.debug?
+
+        if ast.sexp_type == :ExpressionContext && ast.getContext( ast.expressionAst.reference.scopeDefining.sexp_type ) && ast.expressionAst['value'] != Constants::SOL_THIS
+          
+          # if context found for variable scope
+          translation = alApi.tlaRecordField(
+            ast.getContext( ast.expressionAst.reference.scopeDefining.sexp_type ),
+            ast.expressionAst['value']
+          )
+
+        elsif ast.sexp_type == :ExpressionContext
+          
+          # in context but no match -> continue evaluation in context
+          translation =  alApi.expression(identifierReference( ast.expressionAst ))
+
+        else
+          
+          # Resolve direct reference to identifier
+          translation =  alApi.expression(identifierReference( ast ))
+                                          
+        end
+                                          
+        @logger.debug( "#{__method__}: translation=#{translation.strOutput}") if @logger.debug?
+        translation 
+      end
+
+
+      # Create expression to access indexed element of identifer. Use
+      # {#expressionDispatcher} to dispatch 'identifier' and 'indexer'
+      # expresion of IndexAccess AST node (possible wrapped within
+      # ExpressionContext).
+      #
+      # @param ast [ExpressionContext,IndexAccess] IndexAccess (or
+      #        IndexAccess wrapped in context) to create expression
+      #        for.
+      #
+      #
+      # @return [Al::Expression] expression to access indexed member
+      def indexAccessExpr( ast )
+        @logger.debug "#{__method__}: ast=#{ast}" if @logger.debug?
+
+        if ast.sexp_type == :ExpressionContext
+          indexerAst = ast.expressionAst
+          # eval identifier with context
+          indexExpr = Ethereum.dispatcher(
+            expressionDispatcher,
+            indexerAst.identifier.sexp_type,
+            ExpressionContext.createExpressionContext(indexerAst.identifier, ast.context )
+          )
+          indexer = Ethereum.dispatcher(
+            expressionDispatcher, indexerAst.indexer.sexp_type,
+            ExpressionContext.createExpressionContext(indexerAst.indexer, ast.context )
+          )
+        else
+          indexAccessAst = ast
+          indexExpr = Ethereum.dispatcher(
+            expressionDispatcher,
+            indexerAst.identifier.sexp_type,
+            indexerAst.identifier
+          )
+          indexer = Ethereum.dispatcher(
+            expressionDispatcher, indexerAst.indexer.sexp_type,
+            indexerAst.indexer 
+          )
+        end
+        
+        alApi.tlaRecordIndex( indexExpr, indexer )
+        
+        
+      end
+
+
+      # @!endgroup
+
+      
+      # ------------------------------------------------------------------
+      # @!group Resolve identifier reference
+
+      # Use dispatcher {#referenceContextDispatcher} to create a
+      # reference to 'identifierAst'.
+      #
+      # Impelementation user pointer chain
+      # identifierAst.reference.scopeDefining to find 1) variable
+      # declaration and 2) scope of declaration to dispatch correct
+      # translation method in {#referenceContextDispatcher}.
+      #
+      # @param identifierAst [Identifier] AST node to resolve.
+      def identifierReference( identifierAst )
+        # identifierAst = context[:identifierAst]
+        @logger.debug "#{__method__}: identifierAst=#{identifierAst}" if @logger.debug?
+        @logger.info "#{__method__}: ident:'#{identifierAst['value']}'" +
+                     " decl.ref='#{identifierAst.reference.key?( "name") ? identifierAst.reference['name'] : '??' }:#{identifierAst&.reference.sexp_type}'" +
+                     ", scope='#{identifierAst.reference.scopeDefining.respond_to?( :sexp_type) ? identifierAst.reference.scopeDefining.sexp_type : identifierAst.reference.scopeDefining.class }'" 
+
+        ref = identifierAst.reference.scopeDefining
+        
+        # Reference has already been resolde (e.g. :ModifierIncation)
+        return( ref ) if ref.is_a? Sbuilder::Al::Model::Expression
+        # 
+        Ethereum.dispatcher( referenceContextDispatcher, ref.sexp_type, identifierAst )
+      end
+
+
+      # Reference to identifier depends on the type of the scope,
+      # where the variable, referenced by 'identifierAst', is declared
+      # in.
+      # 
+      # Scope may be ::GlobalScope -> e.g. this, :ContractDefinition
+      # --> contract member variable #{contractContextReference},
+      # :FunctionDefinition --> function local varibale
+      # {#functionContextReference}, :ParameterList --> to access
+      # Solidity 'msg' {#parameterContextReference},
+      # 
+      def referenceContextDispatcher
+        @referenceContextDispatcher ||= {
+          :GlobalScope => method(:globalContextReference),
+          :ContractDefinition =>method(:contractContextReference),
+          :FunctionDefinition =>method(:functionContextReference),
+          :ParameterList=>method(:parameterContextReference),
+        }
+      end
+
+      # Currently runnign contract found in local variable 'refRunningContractAddress'
+      #
+      # @return [Al::Reference] reference to currenly running contract
+      def globalContextReference(identifierAst)
+        @logger.debug "#{__method__}: identifierAst=#{identifierAst}" if @logger.debug?
+        raise "Supports only '#{Constants::SOL_THIS}' - unkwon  #{identifierAst['value']}" unless identifierAst['value'] == Constants::SOL_THIS
+                                                                                                            
+        refRunningContractAddress
+      end
+
+      # # Create a reference for an identifier in :ModifierDefinition
+      # # context, which has been invoked :ModifierInvocation for a
+      # # function (sexp_type :FunctionDefinition).
+      # def modifierContextReference( identifierAst )
+      #   @logger.debug "#{__method__}: identifierAst=#{identifierAst}" if @logger.debug?
+      #   functionAst =  identifierAst.reference.scopeDefining
+      #   raise "identifierAst=#{identifierAst}\n\nidentifierAst.reference=#{identifierAst.reference}\n\nfunctionAst=#{functionAst}"
+      # end
+      
+      # Create a reference to member variable of currently running
+      # contract.
+      #
+      #  Contract members variables are fields in records in
+      #  'storageRoot' variable. Current contract is pointed by
+      #  {#refRunningContractAddress} (, which is local variable with
+      #  the 'address' of currently running contract ).
+      #
+      def contractContextReference( identifierAst  )
+        @logger.debug "#{__method__}: identifierAst=#{identifierAst}" if @logger.debug?
+        contract =  identifierAst.reference.scopeDefining
+        if identifierAst['value'] == Constants::SOL_THIS
+          # this found in local varible thisCid
+          refRunningContractAddress
+        else
+          ethContractVariableReference( refStorageRoot,  refRunningContractAddress, identifierAst['value'] )
+        end
+      end
+
+      # Translate reference to function local variable.
+      def functionContextReference( identifierAst )
+        @logger.debug "#{__method__}: identifierAst=#{identifierAst}" if @logger.debug?
+        function =  identifierAst.reference.scopeDefining
+        contract =  function.enclosingScope
+        
+        ethFunctionParameterReference( contract['name'], function['name'] )
+      end 
+                                       
+      # Translate reference to an identifier in function paramers (=Solidity 'msg')
+      #
+      # Msg variable is accessed in a parameter passed to the
+      # procedure created to model 'contract' 'function'.
+      def parameterContextReference( identifierAst )
+        @logger.debug "#{__method__}: identifierAst=#{identifierAst}" if @logger.debug?
+        function =  identifierAst.reference.scopeDefining.enclosingScope
+        contract =  function.enclosingScope          
+        ethFunctionParameterReference( contract['name'], function['name'], identifierAst['value'] )
+      end
+      
+
+      # @!endgroup
+      
+    end
+  end
+end