integration tests for 2 contracts updated

remix-analyzer/src/solidity-analyzer/index.ts

@@ -18,7 +18,9 @@ export default class staticAnalysisRunner {
     // Also provide convenience analysis via the AST walker.
     const walker = new AstWalker()
     for (let k in compilationResult.sources) {
-      walker.walk(compilationResult.sources[k].AST, {'*': (node) => {
+      // console.log('Ast in walker---', compilationResult.sources[k])
+      walker.walkFull(compilationResult.sources[k].ast, 
+        (node) => {
         modules.map((item, i) => {
           if (item.mod.visit !== undefined) {
             try {
@@ -31,7 +33,8 @@ export default class staticAnalysisRunner {
           }
         })
         return true
-      }})
+      }
+      )
     }
 
     // Here, modules can just collect the results from the AST walk,

remix-analyzer/src/solidity-analyzer/modules/assignAndCompare.ts

@@ -11,7 +11,7 @@ export default class assignAndCompare implements AnalyzerModule {
   algorithm: ModuleAlgorithm = algorithm.EXACT
 
   visit (node: BlockAstNode | IfStatementAstNode | WhileStatementAstNode | ForStatementAstNode): void {
-    if (isSubScopeWithTopLevelUnAssignedBinOp(node)) getUnAssignedTopLevelBinOps(node).forEach((n) => this.warningNodes.push(n))
+    if (node && node.nodeType && isSubScopeWithTopLevelUnAssignedBinOp(node)) getUnAssignedTopLevelBinOps(node).forEach((n) => this.warningNodes.push(n))
   }
 
   report (compilationResults: CompilationResult): ReportObj[] {

remix-analyzer/src/solidity-analyzer/modules/blockBlockhash.ts

@@ -11,7 +11,7 @@ export default class blockBlockhash implements AnalyzerModule {
   algorithm: ModuleAlgorithm = algorithm.EXACT
 
   visit (node: FunctionCallAstNode): void {
-    if (isBlockBlockHashAccess(node)) this.warningNodes.push(node)
+    if (node.nodeType === 'FunctionCall' && isBlockBlockHashAccess(node)) this.warningNodes.push(node)
   }
 
   report (compilationResults: CompilationResult): ReportObj[] {

remix-analyzer/src/solidity-analyzer/modules/checksEffectsInteraction.ts

@@ -43,7 +43,7 @@ export default class checksEffectsInteraction implements AnalyzerModule {
           comments += (multipleContractsWithSameName) ? 'Note: Import aliases are currently not supported by this static analysis.' : ''
           warnings.push({
             warning: `Potential Violation of Checks-Effects-Interaction pattern in ${funcName}: Could potentially lead to re-entrancy vulnerability. ${comments}`,
-            location: func['src'],
+            location: func.node['src'],
             more: 'http://solidity.readthedocs.io/en/develop/security-considerations.html#re-entrancy'
           })
         }

remix-analyzer/src/solidity-analyzer/modules/constantFunctions.ts

@@ -64,13 +64,13 @@ export default class constantFunctions implements AnalyzerModule {
           if (func['potentiallyshouldBeConst']) {
             warnings.push({
               warning: `${funcName} : Potentially should be constant but is not. ${comments}`,
-              location: func['src'],
+              location: func.node['src'],
               more: 'http://solidity.readthedocs.io/en/develop/contracts.html#constant-functions'
             })
           } else {
             warnings.push({
               warning: `${funcName} : Is constant but potentially should not be. ${comments}`,
-              location: func['src'],
+              location: func.node['src'],
               more: 'http://solidity.readthedocs.io/en/develop/contracts.html#constant-functions'
             })
           }
@@ -88,7 +88,7 @@ export default class constantFunctions implements AnalyzerModule {
     return contract.stateVariables.concat(func.localVariables.filter(isStorageVariableDeclaration))
   }
 
-  private checkIfShouldBeConstant (startFuncName: string, context): boolean {
+  private checkIfShouldBeConstant (startFuncName: string, context: Context): boolean {
     return !analyseCallGraph(context.callGraph, startFuncName, context, this.isConstBreaker.bind(this))
   }
 

remix-analyzer/src/solidity-analyzer/modules/etherTransferInLoop.ts

@@ -12,11 +12,11 @@ export default class etherTransferInLoop implements AnalyzerModule {
   
   visit (node: ForStatementAstNode | WhileStatementAstNode): void {
       let transferNodes: ExpressionStatementAstNode[] = []
-      if(node.body.nodeType === 'Block')
+      if(node.body && node.body.nodeType === 'Block')
         transferNodes = node.body.statements.filter(child => ( child.nodeType === 'ExpressionStatement' &&
                           child.expression.nodeType === 'FunctionCall' && isTransfer(child.expression.expression)))
       // When loop body is described without braces
-      else if(node.body.nodeType === 'ExpressionStatement' && node.body.expression.nodeType === 'FunctionCall' && isTransfer(node.body.expression.expression))
+      else if(node.body && node.body.nodeType === 'ExpressionStatement' && node.body.expression.nodeType === 'FunctionCall' && isTransfer(node.body.expression.expression))
         transferNodes.push(node.body)
       if (transferNodes.length > 0) {
         this.relevantNodes.push(...transferNodes)

remix-analyzer/src/solidity-analyzer/modules/forLoopIteratesOverDynamicArray.ts

@@ -13,9 +13,9 @@ export default class forLoopIteratesOverDynamicArray implements AnalyzerModule {
   visit (node: ForStatementAstNode): void {
       const  { condition } = node
       // Check if condition is `i < array.length - 1`
-      if ((condition.nodeType === "BinaryOperation"  && condition.rightExpression.nodeType === "BinaryOperation" && isDynamicArrayLengthAccess(condition.rightExpression.leftExpression)) || 
+      if ((condition && condition.nodeType === "BinaryOperation"  && condition.rightExpression.nodeType === "BinaryOperation" && isDynamicArrayLengthAccess(condition.rightExpression.leftExpression)) || 
       // or condition is `i < array.length`
-      (condition.nodeType === "BinaryOperation" && isDynamicArrayLengthAccess(condition.rightExpression))) {
+      (condition && condition.nodeType === "BinaryOperation" && isDynamicArrayLengthAccess(condition.rightExpression))) {
         this.relevantNodes.push(node)
       }
   }

remix-analyzer/src/solidity-analyzer/modules/functionCallGraph.ts

@@ -1,8 +1,7 @@
 'use strict'
 
 import { FunctionHLAst, ContractHLAst, FunctionCallGraph, ContractCallGraph } from "types"
-
-const common = require('./staticAnalysisCommon')
+import { isLocalCallGraphRelevantNode,  isExternalDirectCall, getFullQualifiedFunctionCallIdent, getFullQuallyfiedFuncDefinitionIdent, getContractName } from './staticAnalysisCommon'
 
 function buildLocalFuncCallGraphInternal (functions: FunctionHLAst[], nodeFilter: any , extractNodeIdent: any, extractFuncDefIdent: Function): Record<string, FunctionCallGraph> {
   const callGraph: Record<string, FunctionCallGraph> = {}
@@ -44,11 +43,11 @@ function buildLocalFuncCallGraphInternal (functions: FunctionHLAst[], nodeFilter
 export function buildGlobalFuncCallGraph (contracts: ContractHLAst[]): Record<string, ContractCallGraph> {
   const callGraph: Record<string, ContractCallGraph> = {}
   contracts.forEach((contract) => {
-    const filterNodes: Function = (node) => { return common.isLocalCallGraphRelevantNode(node) || common.isExternalDirectCall(node) }
-    const getNodeIdent: Function = (node) => { return common.getFullQualifiedFunctionCallIdent(contract.node, node) }
-    const getFunDefIdent: Function = (funcDef) => { return common.getFullQuallyfiedFuncDefinitionIdent(contract.node, funcDef.node, funcDef.parameters) }
+    const filterNodes: Function = (node) => { return isLocalCallGraphRelevantNode(node) || isExternalDirectCall(node) }
+    const getNodeIdent: Function = (node) => { return getFullQualifiedFunctionCallIdent(contract.node, node) }
+    const getFunDefIdent: Function = (funcDef) => { return getFullQuallyfiedFuncDefinitionIdent(contract.node, funcDef.node, funcDef.parameters) }
 
-    callGraph[common.getContractName(contract.node)] = { contract: contract, functions: buildLocalFuncCallGraphInternal(contract.functions, filterNodes, getNodeIdent, getFunDefIdent) }
+    callGraph[getContractName(contract.node)] = { contract: contract, functions: buildLocalFuncCallGraphInternal(contract.functions, filterNodes, getNodeIdent, getFunDefIdent) }
   })
 
   return callGraph

remix-analyzer/src/solidity-analyzer/modules/inlineAssembly.ts

@@ -10,7 +10,7 @@ export default class inlineAssembly implements AnalyzerModule {
   algorithm: ModuleAlgorithm = algorithm.EXACT
 
   visit (node: InlineAssemblyAstNode): void {
-    this.inlineAssNodes.push(node)
+    if(node.nodeType === 'InlineAssembly') this.inlineAssNodes.push(node)
   }
 
   report (compilationResults: CompilationResult): ReportObj[] {

remix-analyzer/src/solidity-analyzer/modules/selfdestruct.ts

@@ -13,7 +13,7 @@ export default class selfdestruct implements AnalyzerModule {
   abstractAst: AbstractAst = new AbstractAst()
 
   visit: Function = this.abstractAst.build_visit(
-    (node: any) => isStatement(node) || isSelfdestructCall(node.expression)
+    (node: any) => isStatement(node) || ( node.nodeType=== 'FunctionCall' && isSelfdestructCall(node.expression) )
   )
 
   report: Function = this.abstractAst.build_report(this._report.bind(this))

remix-analyzer/src/solidity-analyzer/modules/staticAnalysisCommon.ts

@@ -1,33 +1,61 @@
 'use strict'
 
 import { FunctionDefinitionAstNode, ModifierDefinitionAstNode, ParameterListAstNode, ForStatementAstNode, WhileStatementAstNode, VariableDeclarationAstNode, ContractDefinitionAstNode, InheritanceSpecifierAstNode, MemberAccessAstNode, BinaryOperationAstNode, FunctionCallAstNode, ExpressionStatementAstNode, UnaryOperationAstNode, IdentifierAstNode, MappingAstNode, IndexAccessAstNode, UserDefinedTypeNameAstNode, BlockAstNode, AssignmentAstNode, InlineAssemblyAstNode, IfStatementAstNode } from "types"
-
 import { util } from 'remix-lib'
 
 const nodeTypes = {
-  IDENTIFIER: 'Identifier',
-  MEMBERACCESS: 'MemberAccess',
-  FUNCTIONCALL: 'FunctionCall',
+  SOURCEUNIT: 'SourceUnit',
+  PRAGMADIRECTIVE: 'PragmaDirective',
+  IMPORTDIRECTIVE: 'ImportDirective',
+  CONTRACTDEFINITION: 'ContractDefinition',
+  INHERITANCESPECIFIER: 'InheritanceSpecifier',
+  USINGFORDIRECTIVE: 'UsingForDirective',
+  STRUCTDEFINITION: 'StructDefinition',
+  ENUMDEFINITION: 'EnumDefinition',
+  ENUMVALUE: 'EnumValue',
+  PARAMETERLIST: 'ParameterList',
+  OVERRIDESPECIFIER: 'OverrideSpecifier',
   FUNCTIONDEFINITION: 'FunctionDefinition',
   VARIABLEDECLARATION: 'VariableDeclaration',
-  ASSIGNMENT: 'Assignment',
-  CONTRACTDEFINITION: 'ContractDefinition',
-  UNARYOPERATION: 'UnaryOperation',
-  BINARYOPERATION: 'BinaryOperation',
-  EXPRESSIONSTATEMENT: 'ExpressionStatement',
   MODIFIERDEFINITION: 'ModifierDefinition',
   MODIFIERINVOCATION: 'ModifierInvocation',
-  INHERITANCESPECIFIER: 'InheritanceSpecifier',
+  EVENTDEFINITION: 'EventDefinition',
+  ELEMENTARYTYPENAME: 'ElementaryTypeName',
   USERDEFINEDTYPENAME: 'UserDefinedTypeName',
-  INLINEASSEMBLY: 'InlineAssembly',
+  FUNCTIONTYPENAME: 'FunctionTypeName',
+  MAPPING: 'Mapping',
+  ARRAYTYPENAME: 'ArrayTypeName',
+  INLINEASSEMBLY: 'InlineAssembly', 
   BLOCK: 'Block',
-  NEWEXPRESSION: 'NewExpression',
-  RETURN: 'Return',
+  PLACEHOLDERSTATEMENT: 'PlaceholderStatement', 
   IFSTATEMENT: 'IfStatement',
-  FORSTATEMENT: 'ForStatement',
+  TRYCATCHCLAUSE: 'TryCatchClause', 
+  TRYSTATEMENT: 'TryStatement', 
   WHILESTATEMENT: 'WhileStatement',
   DOWHILESTATEMENT: 'DoWhileStatement',
-  ELEMENTARYTYPENAMEEXPRESSION: 'ElementaryTypeNameExpression'
+  FORSTATEMENT: 'ForStatement',
+  CONTINUE: 'Continue', 
+  BREAK: 'Break', 
+  RETURN: 'Return', 
+  THROW: 'Throw', 
+  EMITSTATEMENT: 'EmitStatement', 
+  VARIABLEDECLARATIONSTATEMENT: 'VariableDeclarationStatement', 
+  EXPRESSIONSTATEMENT: 'ExpressionStatement',
+  CONDITIONAL: 'Conditional', 
+  ASSIGNMENT: 'Assignment',
+  TUPLEEXPRESSION: 'TupleExpression', 
+  UNARYOPERATION: 'UnaryOperation',
+  BINARYOPERATION: 'BinaryOperation',
+  FUNCTIONCALL: 'FunctionCall',
+  FUNCTIONCALLOPTIONS: 'FunctionCallOptions',
+  NEWEXPRESSION: 'NewExpression', 
+  MEMBERACCESS: 'MemberAccess', 
+  INDEXACCESS: 'IndexAccess', 
+  INDEXRANGEACCESS: 'IndexRangeAccess', 
+  ELEMENTARYTYPENAMEEXPRESSION: 'ElementaryTypeNameExpression', 
+  LITERAL: 'Literal', 
+  IDENTIFIER: 'Identifier',
+  STRUCTUREDDOCUMENTATION: 'StructuredDocumentation'
 }
 
 const basicTypes = {
@@ -401,7 +429,7 @@ function getUnAssignedTopLevelBinOps (subScope: BlockAstNode | IfStatementAstNod
   if(subScope.nodeType === 'Block')
     result = subScope.statements.filter(isBinaryOpInExpression)
   // for 'without braces' loops
-  else if (isSubScopeStatement(subScope)) {
+  else if (subScope && subScope.nodeType && isSubScopeStatement(subScope)) {
     if (subScope.nodeType === 'IfStatement'){
       if((subScope.trueBody.nodeType === "ExpressionStatement" && isBinaryOpInExpression(subScope.trueBody)))
         result.push(subScope.trueBody) 
@@ -519,7 +547,7 @@ function isBuiltinFunctionCall (node: FunctionCallAstNode): boolean {
   // console.log('isBuiltinFunctionCall isLocalCall', isLocalCall(node))
   // console.log('isBuiltinFunctionCall getLocalCallName', getLocalCallName(node))
   // console.log('isBuiltinFunctionCall getFunctionCallTypeParameterType', getFunctionCallTypeParameterType(node))
-  return (isLocalCall(node) && builtinFunctions[getLocalCallName(node) + '(' + getFunctionCallTypeParameterType(node) + ')'] === true) || isAbiNamespaceCall(node)
+  return (node.nodeType === 'FunctionCall' && isLocalCall(node) && builtinFunctions[getLocalCallName(node) + '(' + getFunctionCallTypeParameterType(node) + ')'] === true) || isAbiNamespaceCall(node)
 }
 
 /**
@@ -564,6 +592,7 @@ function isRequireCall (node: FunctionCallAstNode): boolean  {
  * @return {bool}
  */
 function isStorageVariableDeclaration (node: VariableDeclarationAstNode): boolean {
+  // console.log('storage variable----------', new RegExp(basicRegex.REFTYPE).test(node.typeDescriptions.typeIdentifier))
   return node.storageLocation === 'storage' && new RegExp(basicRegex.REFTYPE).test(node.typeDescriptions.typeIdentifier)
 }
 
@@ -652,20 +681,21 @@ function isSubScopeWithTopLevelUnAssignedBinOp (node: BlockAstNode | IfStatement
   if(node.nodeType === 'Block')
     return node.statements.some(isBinaryOpInExpression)
   // for 'without braces' loops
-  else if (isSubScopeStatement(node)) {
+  else if (node && node.nodeType && isSubScopeStatement(node)) {
     if (node.nodeType === 'IfStatement')
-      return (node.trueBody.nodeType === "ExpressionStatement" && isBinaryOpInExpression(node.trueBody)) || 
-          (node.falseBody.nodeType === "ExpressionStatement" && isBinaryOpInExpression(node.falseBody))
+      return (node.trueBody && node.trueBody.nodeType === "ExpressionStatement" && isBinaryOpInExpression(node.trueBody)) || 
+          (node.falseBody && node.falseBody.nodeType === "ExpressionStatement" && isBinaryOpInExpression(node.falseBody))
     else 
-      return node.body.nodeType === "ExpressionStatement" && isBinaryOpInExpression(node.body)
+      return node.body && node.body.nodeType === "ExpressionStatement" && isBinaryOpInExpression(node.body)
   } 
 }
 
 function isSubScopeStatement (node: IfStatementAstNode | WhileStatementAstNode | ForStatementAstNode): boolean {
   if(node.nodeType === 'IfStatement')
-    return !nodeType(node.trueBody, exactMatch(nodeTypes.BLOCK)) && !nodeType(node.falseBody, exactMatch(nodeTypes.BLOCK))
+    return (node.trueBody && node.trueBody.nodeType && !nodeType(node.trueBody, exactMatch(nodeTypes.BLOCK))) ||
+        (node.falseBody && node.falseBody.nodeType && !nodeType(node.falseBody, exactMatch(nodeTypes.BLOCK)))
   else      
-    return !nodeType(node.body, exactMatch(nodeTypes.BLOCK))
+    return node.body && node.body.nodeType && !nodeType(node.body, exactMatch(nodeTypes.BLOCK))
 }
 
 /**
@@ -809,7 +839,8 @@ function isSuperLocalCall (node: MemberAccessAstNode): boolean {
  * @return {bool}
  */
 function isLocalCall (node: FunctionCallAstNode): boolean {
-  return node.kind === 'functionCall' && 
+  return node.nodeType === 'FunctionCall' && 
+        node.kind === 'functionCall' && 
         node.expression.nodeType === 'Identifier' &&
         expressionTypeDescription(node, basicRegex.FUNCTIONTYPE) &&
         !expressionTypeDescription(node, basicRegex.EXTERNALFUNCTIONTYPE)
@@ -952,15 +983,17 @@ function isBytesLengthCheck (node: MemberAccessAstNode): boolean {
 // #################### Complex Node Identification - Private
 
 function isMemberAccess (node: MemberAccessAstNode, retType: string, accessor: string| undefined, accessorType: string, memberName: string | undefined): boolean {
-  const nodeTypeDef: boolean = typeDescription(node, retType)
-  console.log('MemberAccess typeDef ->',nodeTypeDef)
-  const nodeMemName: boolean = memName(node, memberName)
-  console.log('MemberAccess nodeMemName ->',nodeMemName)
-  const nodeExpMemName: boolean = memName(node.expression, accessor)
-  console.log('MemberAccess nodeExpMemName ->',nodeExpMemName)
-  const nodeExpTypeDef: boolean = expressionTypeDescription(node, accessorType)
-  console.log('MemberAccess nodeExpTypeDef ->',nodeExpTypeDef)
-  return nodeTypeDef && nodeMemName && nodeExpTypeDef && nodeExpMemName
+  if(node && nodeType(node, exactMatch('MemberAccess'))) {
+    const nodeTypeDef: boolean = typeDescription(node, retType)
+    // console.log('MemberAccess typeDef ->',nodeTypeDef)
+    const nodeMemName: boolean = memName(node, memberName)
+    // console.log('MemberAccess nodeMemName ->',nodeMemName)
+    const nodeExpMemName: boolean = memName(node.expression, accessor)
+    // console.log('MemberAccess nodeExpMemName ->',nodeExpMemName)
+    const nodeExpTypeDef: boolean = expressionTypeDescription(node, accessorType)
+    // console.log('MemberAccess nodeExpTypeDef ->',nodeExpTypeDef)
+    return nodeTypeDef && nodeMemName && nodeExpTypeDef && nodeExpMemName
+  } else return false
 }
 
 function isSpecialVariableAccess (node: MemberAccessAstNode, varType: any): boolean {
@@ -989,11 +1022,15 @@ function typeDescription (node: any, typeRegex: string): boolean {
   return  new RegExp(typeRegex).test(node.typeDescriptions.typeString)
 }
 
-function nodeType (node, typeRegex) {
+function nodeType (node: any, typeRegex: string) {
   return new RegExp(typeRegex).test(node.nodeType)
 }
 
-function memName (node, memNameRegex) {
+function nodeTypeIn (node: any, typeRegex: string[]){
+  return typeRegex.some((typeRegex) => nodeType (node, typeRegex))
+}
+
+function memName (node: any, memNameRegex: any) {
   // const regex = new RegExp(memNameRegex)
   return (node && !memNameRegex) || new RegExp(memNameRegex).test(node.name) || new RegExp(memNameRegex).test(node.memberName)
 }

remix-analyzer/src/solidity-analyzer/modules/thisLocal.ts

@@ -11,7 +11,7 @@ export default class thisLocal implements AnalyzerModule {
   algorithm: ModuleAlgorithm = algorithm.EXACT
 
   visit (node: MemberAccessAstNode): void {
-    if (isThisLocalCall(node)) this.warningNodes.push(node)
+    if (node.nodeType === 'MemberAccess' && isThisLocalCall(node)) this.warningNodes.push(node)
   }
 
   report (compilationResults: CompilationResult): ReportObj[] {

remix-analyzer/test/analysis/staticAnalysisCommon-test.ts

@@ -266,9 +266,8 @@ test('staticAnalysisCommon.getFullQuallyfiedFuncDefinitionIdent', function (t) {
 // #################### Complex Node Identification
 
 test('staticAnalysisCommon.isBuiltinFunctionCall', function (t) {
-  t.plan(2)
+  t.plan(1)
   t.ok(common.isBuiltinFunctionCall(selfdestruct), 'selfdestruct is builtin')
-  t.throws(() => common.isBuiltinFunctionCall(localCall), Error, 'local call is not builtin')
 })
 
 test('staticAnalysisCommon.isStorageVariableDeclaration', function (t) {

remix-analyzer/test/analysis/test-contracts/solidity-v0.5/ballot.sol

@@ -121,7 +121,7 @@ contract Ballot {
 
     /// @dev Computes the winning proposal taking all
     /// previous votes into account.
-    function winningProposal() view public
+    function winningProposal() public view
             returns (uint winningProposal)
     {
         uint winningVoteCount = 0;