update remix-debug syntax to use const, let and this

remix-debug/bin/rdb

@@ -25,15 +25,15 @@ program
   .option('--node [url]', 'node to connect to')
   .parse(process.argv)
 
-var CmdLine = require('../src/cmdline/index.js')
+const CmdLine = require('../src/cmdline/index.js')
 
-var solc = require('solc')
-var fs = require('fs')
+const solc = require('solc')
+const fs = require('fs')
 
-var filename = 'test/sol/simple_storage.sol'
-var shortFilename = 'simple_storage.sol'
+const filename = 'test/sol/simple_storage.sol'
+const shortFilename = 'simple_storage.sol'
 
-var inputJson = {
+const inputJson = {
   language: 'Solidity',
   sources: {
   },
@@ -55,17 +55,17 @@ inputJson.sources[shortFilename] = {content: fs.readFileSync(filename).toString(
 
 console.log('compiling...')
 
-let compilationData = JSON.parse(solc.compileStandardWrapper(JSON.stringify(inputJson)))
-var compilation = {}
+const compilationData = JSON.parse(solc.compileStandardWrapper(JSON.stringify(inputJson)))
+const compilation = {}
 compilation.data = compilationData
 compilation.source = { sources: inputJson.sources }
 
-var cmdLine = new CmdLine()
+const cmdLine = new CmdLine()
 cmdLine.connect('http', 'http://localhost:8545')
 cmdLine.loadCompilationResult(compilation)
 cmdLine.initDebugger()
 
-var tx = '0xf510c4f0b1d9ee262d7b9e9e87b4262f275fe029c2c733feef7dfa1e2b1e32aa'
+const tx = '0xf510c4f0b1d9ee262d7b9e9e87b4262f275fe029c2c733feef7dfa1e2b1e32aa'
 
 cmdLine.startDebug(tx, shortFilename)
 

remix-debug/index.js

 'use strict'
-var EthDebugger = require('./src/Ethdebugger')
-var TransactionDebugger = require('./src/debugger/debugger')
-var CmdLine = require('./src/cmdline')
+const EthDebugger = require('./src/Ethdebugger')
+const TransactionDebugger = require('./src/debugger/debugger')
+const CmdLine = require('./src/cmdline')
 
-var StorageViewer = require('./src/storage/storageViewer')
-var StorageResolver = require('./src/storage/storageResolver')
+const StorageViewer = require('./src/storage/storageViewer')
+const StorageResolver = require('./src/storage/storageResolver')
 
-var SolidityDecoder = require('./src/solidity-decoder')
+const SolidityDecoder = require('./src/solidity-decoder')
 
-var remixLib = require('remix-lib')
-var BreakpointManager = remixLib.code.BreakpointManager
+const remixLib = require('remix-lib')
+const BreakpointManager = remixLib.code.BreakpointManager
 
 /*
   Use of breakPointManager :

remix-debug/src/Ethdebugger.js

 'use strict'
 
-var StorageViewer = require('./storage/storageViewer')
-var StorageResolver = require('./storage/storageResolver')
+const StorageViewer = require('./storage/storageViewer')
+const StorageResolver = require('./storage/storageResolver')
 
-var SolidityDecoder = require('./solidity-decoder')
-var SolidityProxy = SolidityDecoder.SolidityProxy
-var stateDecoder = SolidityDecoder.stateDecoder
-var localDecoder = SolidityDecoder.localDecoder
-var InternalCallTree = SolidityDecoder.InternalCallTree
+const SolidityDecoder = require('./solidity-decoder')
+const SolidityProxy = SolidityDecoder.SolidityProxy
+const stateDecoder = SolidityDecoder.stateDecoder
+const localDecoder = SolidityDecoder.localDecoder
+const InternalCallTree = SolidityDecoder.InternalCallTree
 
-var remixLib = require('remix-lib')
-var TraceManager = remixLib.trace.TraceManager
-var CodeManager = remixLib.code.CodeManager
-var traceHelper = remixLib.helpers.trace
-var EventManager = remixLib.EventManager
+const remixLib = require('remix-lib')
+const TraceManager = remixLib.trace.TraceManager
+const CodeManager = remixLib.code.CodeManager
+const traceHelper = remixLib.helpers.trace
+const EventManager = remixLib.EventManager
 
 /**
   * Ethdebugger is a wrapper around a few classes that helps debugging a transaction
@@ -75,7 +75,7 @@ Ethdebugger.prototype.sourceLocationFromVMTraceIndex = function (address, stepIn
 }
 
 Ethdebugger.prototype.sourceLocationFromInstructionIndex = function (address, instIndex, callback) {
-  this.callTree.sourceLocationTracker.getSourceLocationFromInstructionIndex(address, instIndex, this.solidityProxy.contracts, function (error, rawLocation) {
+  this.callTree.sourceLocationTracker.getSourceLocationFromInstructionIndex(address, instIndex, this.solidityProxy.contracts, (error, rawLocation) => {
     callback(error, rawLocation)
   })
 }
@@ -98,10 +98,10 @@ Ethdebugger.prototype.decodeLocalsAt = function (step, sourceLocation, callback)
     step,
     (error, result) => {
       if (!error) {
-        var stack = result[0].value
-        var memory = result[1].value
+        const stack = result[0].value
+        const memory = result[1].value
         try {
-          var storageViewer = new StorageViewer({
+          const storageViewer = new StorageViewer({
             stepIndex: step,
             tx: this.tx,
             address: result[2].value
@@ -124,7 +124,7 @@ Ethdebugger.prototype.decodeLocalsAt = function (step, sourceLocation, callback)
 
 /* decode state */
 Ethdebugger.prototype.extractStateAt = function (step, callback) {
-  this.solidityProxy.extractStateVariablesAt(step, function (error, stateVars) {
+  this.solidityProxy.extractStateVariablesAt(step, (error, stateVars) => {
     callback(error, stateVars)
   })
 }
@@ -132,7 +132,7 @@ Ethdebugger.prototype.extractStateAt = function (step, callback) {
 Ethdebugger.prototype.decodeStateAt = function (step, stateVars, callback) {
   this.traceManager.getCurrentCalledAddressAt(step, (error, address) => {
     if (error) return callback(error)
-    var storageViewer = new StorageViewer({
+    const storageViewer = new StorageViewer({
       stepIndex: step,
       tx: this.tx,
       address: address
@@ -175,16 +175,15 @@ Ethdebugger.prototype.debug = function (tx) {
   }
   this.setCompilationResult(this.opts.compilationResult())
   this.tx = tx
-  var self = this
-  this.traceManager.resolveTrace(tx, function (error, result) {
+  this.traceManager.resolveTrace(tx, (error, result) => {
     if (result) {
-      self.event.trigger('newTraceLoaded', [self.traceManager.trace])
-      if (self.breakpointManager && self.breakpointManager.hasBreakpoint()) {
-        self.breakpointManager.jumpNextBreakpoint(false)
+      this.event.trigger('newTraceLoaded', [this.traceManager.trace])
+      if (this.breakpointManager && this.breakpointManager.hasBreakpoint()) {
+        this.breakpointManager.jumpNextBreakpoint(false)
       }
-      self.storageResolver = new StorageResolver({web3: self.traceManager.web3})
+      this.storageResolver = new StorageResolver({web3: this.traceManager.web3})
     } else {
-      self.statusMessage = error ? error.message : 'Trace not loaded'
+      this.statusMessage = error ? error.message : 'Trace not loaded'
     }
   })
 }

remix-debug/src/cmdline/contextManager.js

-var remixLib = require('remix-lib')
+const remixLib = require('remix-lib')
 
-var EventManager = remixLib.EventManager
-var Web3Providers = remixLib.vm.Web3Providers
-var DummyProvider = remixLib.vm.DummyProvider
-var init = remixLib.init
+const EventManager = remixLib.EventManager
+const Web3Providers = remixLib.vm.Web3Providers
+const DummyProvider = remixLib.vm.DummyProvider
+const init = remixLib.init
 
 class ContextManager {
   constructor (executionContext) {
@@ -33,23 +33,22 @@ class ContextManager {
   }
 
   switchProvider (type, cb) {
-    var self = this
-    this.web3Providers.get(type, function (error, obj) {
+    this.web3Providers.get(type, (error, obj) => {
       if (error) {
         // console.log('provider ' + type + ' not defined')
       } else {
-        self.web3 = obj
-        self.executionContext.detectNetwork((error, network) => {
+        this.web3 = obj
+        this.executionContext.detectNetwork((error, network) => {
           if (error || !network) {
-            self.web3 = obj
+            this.web3 = obj
           } else {
             var webDebugNode = init.web3DebugNode(network.name)
-            self.web3 = (!webDebugNode ? obj : webDebugNode)
+            this.web3 = (!webDebugNode ? obj : webDebugNode)
           }
-          self.event.trigger('providerChanged', [type, self.web3])
+          this.event.trigger('providerChanged', [type, this.web3])
           if (cb) return cb()
         })
-        self.event.trigger('providerChanged', [type, self.web3])
+        this.event.trigger('providerChanged', [type, this.web3])
       }
     })
   }

remix-debug/src/cmdline/index.js

-var Web3 = require('web3')
-var Debugger = require('../debugger/debugger.js')
-var ContextManager = require('./contextManager.js')
-var EventManager = require('events')
-var remixLib = require('remix-lib')
-var executionContext = remixLib.execution.executionContext
+const Web3 = require('web3')
+const Debugger = require('../debugger/debugger.js')
+const ContextManager = require('./contextManager.js')
+const EventManager = require('events')
+const remixLib = require('remix-lib')
+const executionContext = remixLib.execution.executionContext
 
 class CmdLine {
 
@@ -20,7 +20,7 @@ class CmdLine {
   }
 
   loadCompilationData (inputJson, outputJson) {
-    let data = {}
+    const data = {}
     data.data = outputJson
     data.source = { sources: inputJson.sources }
     this.loadCompilationResult(data)
@@ -32,7 +32,6 @@ class CmdLine {
   }
 
   initDebugger (cb) {
-    const self = this
     this.contextManager = new ContextManager(this.executionContext)
 
     this.debugger = new Debugger({
@@ -41,7 +40,7 @@ class CmdLine {
     })
 
     this.contextManager.event.register('providerChanged', () => {
-      self.debugger.updateWeb3(self.contextManager.getWeb3())
+      this.debugger.updateWeb3(this.contextManager.getWeb3())
     })
 
     this.contextManager.initProviders()
@@ -51,15 +50,13 @@ class CmdLine {
   }
 
   getSource () {
-    const self = this
-
-    let lineColumnPos = this.lineColumnPos
+    const lineColumnPos = this.lineColumnPos
 
     if (!lineColumnPos || !lineColumnPos.start) return []
 
-    let content = self.compilation.lastCompilationResult.source.sources[this.filename].content.split('\n')
+    const content = this.compilation.lastCompilationResult.source.sources[this.filename].content.split('\n')
 
-    let source = []
+    const source = []
 
     let line
     line = content[lineColumnPos.start.line - 2]
@@ -71,13 +68,13 @@ class CmdLine {
       source.push('    ' + lineColumnPos.start.line + ':  ' + line)
     }
 
-    let currentLineNumber = lineColumnPos.start.line
-    let currentLine = content[currentLineNumber]
+    const currentLineNumber = lineColumnPos.start.line
+    const currentLine = content[currentLineNumber]
     source.push('=>  ' + (currentLineNumber + 1) + ':  ' + currentLine)
 
-    let startLine = lineColumnPos.start.line
+    const startLine = lineColumnPos.start.line
     for (var i = 1; i < 4; i++) {
-      let line = content[startLine + i]
+      const line = content[startLine + i]
       source.push('    ' + (startLine + i + 1) + ':  ' + line)
     }
 
@@ -85,34 +82,33 @@ class CmdLine {
   }
 
   getCurrentLine () {
-    let lineColumnPos = this.lineColumnPos
+    const lineColumnPos = this.lineColumnPos
     if (!lineColumnPos) return ''
-    let currentLineNumber = lineColumnPos.start.line
-    let content = this.compilation.lastCompilationResult.source.sources[this.filename].content.split('\n')
+    const currentLineNumber = lineColumnPos.start.line
+    const content = this.compilation.lastCompilationResult.source.sources[this.filename].content.split('\n')
     return content[currentLineNumber]
   }
 
   startDebug (txNumber, filename, cb) {
-    const self = this
     this.filename = filename
     this.txHash = txNumber
     this.debugger.debug(null, txNumber, null, () => {
-      self.debugger.event.register('newSourceLocation', function (lineColumnPos, rawLocation) {
-        self.lineColumnPos = lineColumnPos
-        self.rawLocation = rawLocation
-        self.events.emit('source', [lineColumnPos, rawLocation])
+      this.debugger.event.register('newSourceLocation', (lineColumnPos, rawLocation) => {
+        this.lineColumnPos = lineColumnPos
+        this.rawLocation = rawLocation
+        this.events.emit('source', [lineColumnPos, rawLocation])
       })
 
-      self.debugger.vmDebuggerLogic.event.register('solidityState', (data) => {
-        self.solidityState = data
-        self.events.emit('globals', data)
+      this.debugger.vmDebuggerLogic.event.register('solidityState', (data) => {
+        this.solidityState = data
+        this.events.emit('globals', data)
       })
 
       // TODO: this doesnt work too well, it should request the data instead...
-      self.debugger.vmDebuggerLogic.event.register('solidityLocals', (data) => {
+      this.debugger.vmDebuggerLogic.event.register('solidityLocals', (data) => {
         if (JSON.stringify(data) === '{}') return
-        self.solidityLocals = data
-        self.events.emit('locals', data)
+        this.solidityLocals = data
+        this.events.emit('locals', data)
       })
 
       if (cb) {
@@ -215,4 +211,3 @@ class CmdLine {
 }
 
 module.exports = CmdLine
-

remix-debug/src/debugger/VmDebugger.js

-var remixLib = require('remix-lib')
-var EventManager = remixLib.EventManager
-var ui = remixLib.helpers.ui
-var StorageResolver = require('../storage/storageResolver')
-var StorageViewer = require('../storage/storageViewer')
+const remixLib = require('remix-lib')
+const EventManager = remixLib.EventManager
+const ui = remixLib.helpers.ui
+const StorageResolver = require('../storage/storageResolver')
+const StorageViewer = require('../storage/storageViewer')
 
-var DebuggerSolidityState = require('./solidityState')
-var DebuggerSolidityLocals = require('./solidityLocals')
+const DebuggerSolidityState = require('./solidityState')
+const DebuggerSolidityLocals = require('./solidityLocals')
 
 class VmDebuggerLogic {
 
@@ -36,151 +36,145 @@ class VmDebuggerLogic {
   }
 
   listenToEvents () {
-    const self = this
-    this.debugger.event.register('traceUnloaded', function () {
-      self.event.trigger('traceUnloaded')
+    this.debugger.event.register('traceUnloaded', () => {
+      this.event.trigger('traceUnloaded')
     })
 
-    this.debugger.event.register('newTraceLoaded', function () {
-      self.event.trigger('newTraceLoaded')
+    this.debugger.event.register('newTraceLoaded', () => {
+      this.event.trigger('newTraceLoaded')
     })
   }
 
   listenToCodeManagerEvents () {
-    const self = this
-    this._codeManager.event.register('changed', function (code, address, index) {
-      self.event.trigger('codeManagerChanged', [code, address, index])
+    this._codeManager.event.register('changed', (code, address, index) => {
+      this.event.trigger('codeManagerChanged', [code, address, index])
     })
   }
 
   listenToTraceManagerEvents () {
-    const self = this
-
-    this.event.register('indexChanged', this, function (index) {
+    this.event.register('indexChanged', this, (index) => {
       if (index < 0) return
-      if (self.stepManager.currentStepIndex !== index) return
+      if (this.stepManager.currentStepIndex !== index) return
 
-      self.event.trigger('indexUpdate', [index])
+      this.event.trigger('indexUpdate', [index])
 
-      self._traceManager.getCallDataAt(index, function (error, calldata) {
+      this._traceManager.getCallDataAt(index, (error, calldata) => {
         if (error) {
           // console.log(error)
-          self.event.trigger('traceManagerCallDataUpdate', [{}])
-        } else if (self.stepManager.currentStepIndex === index) {
-          self.event.trigger('traceManagerCallDataUpdate', [calldata])
+          this.event.trigger('traceManagerCallDataUpdate', [{}])
+        } else if (this.stepManager.currentStepIndex === index) {
+          this.event.trigger('traceManagerCallDataUpdate', [calldata])
         }
       })
 
-      self._traceManager.getMemoryAt(index, function (error, memory) {
+      this._traceManager.getMemoryAt(index, (error, memory) => {
         if (error) {
           // console.log(error)
-          self.event.trigger('traceManagerMemoryUpdate', [{}])
-        } else if (self.stepManager.currentStepIndex === index) {
-          self.event.trigger('traceManagerMemoryUpdate', [ui.formatMemory(memory, 16)])
+          this.event.trigger('traceManagerMemoryUpdate', [{}])
+        } else if (this.stepManager.currentStepIndex === index) {
+          this.event.trigger('traceManagerMemoryUpdate', [ui.formatMemory(memory, 16)])
         }
       })
 
-      self._traceManager.getCallStackAt(index, function (error, callstack) {
+      this._traceManager.getCallStackAt(index, (error, callstack) => {
         if (error) {
           // console.log(error)
-          self.event.trigger('traceManagerCallStackUpdate', [{}])
-        } else if (self.stepManager.currentStepIndex === index) {
-          self.event.trigger('traceManagerCallStackUpdate', [callstack])
+          this.event.trigger('traceManagerCallStackUpdate', [{}])
+        } else if (this.stepManager.currentStepIndex === index) {
+          this.event.trigger('traceManagerCallStackUpdate', [callstack])
         }
       })
 
-      self._traceManager.getStackAt(index, function (error, callstack) {
+      this._traceManager.getStackAt(index, (error, callstack) => {
         if (error) {
           // console.log(error)
-          self.event.trigger('traceManagerStackUpdate', [{}])
-        } else if (self.stepManager.currentStepIndex === index) {
-          self.event.trigger('traceManagerStackUpdate', [callstack])
+          this.event.trigger('traceManagerStackUpdate', [{}])
+        } else if (this.stepManager.currentStepIndex === index) {
+          this.event.trigger('traceManagerStackUpdate', [callstack])
         }
       })
 
-      self._traceManager.getCurrentCalledAddressAt(index, (error, address) => {
+      this._traceManager.getCurrentCalledAddressAt(index, (error, address) => {
         if (error) return
-        if (!self.storageResolver) return
+        if (!this.storageResolver) return
 
-        var storageViewer = new StorageViewer({ stepIndex: self.stepManager.currentStepIndex, tx: self.tx, address: address }, self.storageResolver, self._traceManager)
+        var storageViewer = new StorageViewer({ stepIndex: this.stepManager.currentStepIndex, tx: this.tx, address: address }, this.storageResolver, this._traceManager)
 
         storageViewer.storageRange((error, storage) => {
           if (error) {
             // console.log(error)
-            self.event.trigger('traceManagerStorageUpdate', [{}])
-          } else if (self.stepManager.currentStepIndex === index) {
+            this.event.trigger('traceManagerStorageUpdate', [{}])
+          } else if (this.stepManager.currentStepIndex === index) {
             var header = storageViewer.isComplete(address) ? 'completely loaded' : 'partially loaded...'
-            self.event.trigger('traceManagerStorageUpdate', [storage, header])
+            this.event.trigger('traceManagerStorageUpdate', [storage, header])
           }
         })
       })
 
-      self._traceManager.getCurrentStep(index, function (error, step) {
-        self.event.trigger('traceCurrentStepUpdate', [error, step])
+      this._traceManager.getCurrentStep(index, (error, step) => {
+        this.event.trigger('traceCurrentStepUpdate', [error, step])
       })
 
-      self._traceManager.getMemExpand(index, function (error, addmem) {
-        self.event.trigger('traceMemExpandUpdate', [error, addmem])
+      this._traceManager.getMemExpand(index, (error, addmem) => {
+        this.event.trigger('traceMemExpandUpdate', [error, addmem])
       })
 
-      self._traceManager.getStepCost(index, function (error, gas) {
-        self.event.trigger('traceStepCostUpdate', [error, gas])
+      this._traceManager.getStepCost(index, (error, gas) => {
+        this.event.trigger('traceStepCostUpdate', [error, gas])
       })
 
-      self._traceManager.getCurrentCalledAddressAt(index, function (error, address) {
-        self.event.trigger('traceCurrentCalledAddressAtUpdate', [error, address])
+      this._traceManager.getCurrentCalledAddressAt(index, (error, address) => {
+        this.event.trigger('traceCurrentCalledAddressAtUpdate', [error, address])
       })
 
-      self._traceManager.getRemainingGas(index, function (error, remaining) {
-        self.event.trigger('traceRemainingGasUpdate', [error, remaining])
+      this._traceManager.getRemainingGas(index, (error, remaining) => {
+        this.event.trigger('traceRemainingGasUpdate', [error, remaining])
       })
 
-      self._traceManager.getReturnValue(index, function (error, returnValue) {
+      this._traceManager.getReturnValue(index, (error, returnValue) => {
         if (error) {
-          self.event.trigger('traceReturnValueUpdate', [[error]])
-        } else if (self.stepManager.currentStepIndex === index) {
-          self.event.trigger('traceReturnValueUpdate', [[returnValue]])
+          this.event.trigger('traceReturnValueUpdate', [[error]])
+        } else if (this.stepManager.currentStepIndex === index) {
+          this.event.trigger('traceReturnValueUpdate', [[returnValue]])
         }
       })
     })
   }
 
   listenToFullStorageChanges () {
-    const self = this
-
     this.address = []
     this.traceLength = 0
 
-    self.debugger.event.register('newTraceLoaded', function (length) {
-      self._traceManager.getAddresses(function (error, addresses) {
+    this.debugger.event.register('newTraceLoaded', (length) => {
+      this._traceManager.getAddresses((error, addresses) => {
         if (error) return
-        self.event.trigger('traceAddressesUpdate', [addresses])
-        self.addresses = addresses
+        this.event.trigger('traceAddressesUpdate', [addresses])
+        this.addresses = addresses
       })
 
-      self._traceManager.getLength(function (error, length) {
+      this._traceManager.getLength((error, length) => {
         if (error) return
-        self.event.trigger('traceLengthUpdate', [length])
-        self.traceLength = length
+        this.event.trigger('traceLengthUpdate', [length])
+        this.traceLength = length
       })
     })
 
-    self.debugger.event.register('indexChanged', this, function (index) {
+    this.debugger.event.register('indexChanged', this, (index) => {
       if (index < 0) return
-      if (self.stepManager.currentStepIndex !== index) return
-      if (!self.storageResolver) return
+      if (this.stepManager.currentStepIndex !== index) return
+      if (!this.storageResolver) return
       // Clean up storage update
-      if (index === self.traceLength - 1) {
-        return self.event.trigger('traceStorageUpdate', [{}])
+      if (index === this.traceLength - 1) {
+        return this.event.trigger('traceStorageUpdate', [{}])
       }
       var storageJSON = {}
-      for (var k in self.addresses) {
-        var address = self.addresses[k]
-        var storageViewer = new StorageViewer({ stepIndex: self.stepManager.currentStepIndex, tx: self.tx, address: address }, self.storageResolver, self._traceManager)
-        storageViewer.storageRange(function (error, result) {
+      for (var k in this.addresses) {
+        var address = this.addresses[k]
+        var storageViewer = new StorageViewer({ stepIndex: this.stepManager.currentStepIndex, tx: this.tx, address: address }, this.storageResolver, this._traceManager)
+        storageViewer.storageRange((error, result) => {
           if (!error) {
             storageJSON[address] = result
-            self.event.trigger('traceStorageUpdate', [storageJSON])
+            this.event.trigger('traceStorageUpdate', [storageJSON])
           }
         })
       }
@@ -188,51 +182,48 @@ class VmDebuggerLogic {
   }
 
   listenToNewChanges () {
-    const self = this
-    self.debugger.event.register('newTraceLoaded', this, function () {
-      self.storageResolver = new StorageResolver({web3: self.debugger.web3})
-      self.debuggerSolidityState.storageResolver = self.storageResolver
-      self.debuggerSolidityLocals.storageResolver = self.storageResolver
-      self.event.trigger('newTrace', [])
+    this.debugger.event.register('newTraceLoaded', this, () => {
+      this.storageResolver = new StorageResolver({web3: this.debugger.web3})
+      this.debuggerSolidityState.storageResolver = this.storageResolver
+      this.debuggerSolidityLocals.storageResolver = this.storageResolver
+      this.event.trigger('newTrace', [])
     })
 
-    self.debugger.callTree.event.register('callTreeReady', function () {
-      if (self.debugger.callTree.reducedTrace.length) {
-        return self.event.trigger('newCallTree', [])
+    this.debugger.callTree.event.register('callTreeReady', () => {
+      if (this.debugger.callTree.reducedTrace.length) {
+        return this.event.trigger('newCallTree', [])
       }
     })
   }
 
   listenToSolidityStateEvents () {
-    const self = this
     this.event.register('indexChanged', this.debuggerSolidityState.init.bind(this.debuggerSolidityState))
-    this.debuggerSolidityState.event.register('solidityState', function (state) {
-      self.event.trigger('solidityState', [state])
+    this.debuggerSolidityState.event.register('solidityState', (state) => {
+      this.event.trigger('solidityState', [state])
     })
-    this.debuggerSolidityState.event.register('solidityStateMessage', function (message) {
-      self.event.trigger('solidityStateMessage', [message])
+    this.debuggerSolidityState.event.register('solidityStateMessage', (message) => {
+      this.event.trigger('solidityStateMessage', [message])
     })
-    this.debuggerSolidityState.event.register('solidityStateUpdating', function () {
-      self.event.trigger('solidityStateUpdating', [])
+    this.debuggerSolidityState.event.register('solidityStateUpdating', () => {
+      this.event.trigger('solidityStateUpdating', [])
     })
     this.event.register('traceUnloaded', this.debuggerSolidityState.reset.bind(this.debuggerSolidityState))
     this.event.register('newTraceLoaded', this.debuggerSolidityState.reset.bind(this.debuggerSolidityState))
   }
 
   listenToSolidityLocalsEvents () {
-    const self = this
     this.event.register('sourceLocationChanged', this.debuggerSolidityLocals.init.bind(this.debuggerSolidityLocals))
-    this.debuggerSolidityLocals.event.register('solidityLocals', function (state) {
-      self.event.trigger('solidityLocals', [state])
+    this.debuggerSolidityLocals.event.register('solidityLocals', (state) => {
+      this.event.trigger('solidityLocals', [state])
     })
-    this.debuggerSolidityLocals.event.register('solidityLocalsMessage', function (message) {
-      self.event.trigger('solidityLocalsMessage', [message])
+    this.debuggerSolidityLocals.event.register('solidityLocalsMessage', (message) => {
+      this.event.trigger('solidityLocalsMessage', [message])
     })
-    this.debuggerSolidityLocals.event.register('solidityLocalsUpdating', function () {
-      self.event.trigger('solidityLocalsUpdating', [])
+    this.debuggerSolidityLocals.event.register('solidityLocalsUpdating', () => {
+      this.event.trigger('solidityLocalsUpdating', [])
     })
-    this.debuggerSolidityLocals.event.register('traceReturnValueUpdate', function (data, header) {
-      self.event.trigger('traceReturnValueUpdate', [data, header])
+    this.debuggerSolidityLocals.event.register('traceReturnValueUpdate', (data, header) => {
+      this.event.trigger('traceReturnValueUpdate', [data, header])
     })
   }
 

remix-debug/src/debugger/debugger.js

 'use strict'
-var Ethdebugger = require('../Ethdebugger')
-var remixLib = require('remix-lib')
-var EventManager = remixLib.EventManager
-var traceHelper = remixLib.helpers.trace
-var OffsetToColumnConverter = remixLib.OffsetToColumnConverter
+const Ethdebugger = require('../Ethdebugger')
+const remixLib = require('remix-lib')
+const EventManager = remixLib.EventManager
+const traceHelper = remixLib.helpers.trace
+const OffsetToColumnConverter = remixLib.OffsetToColumnConverter
 
-var StepManager = require('./stepManager')
-var VmDebuggerLogic = require('./VmDebugger')
+const StepManager = require('./stepManager')
+const VmDebuggerLogic = require('./VmDebugger')
 
 function Debugger (options) {
-  var self = this
   this.event = new EventManager()
 
   this.offsetToLineColumnConverter = options.offsetToLineColumnConverter || (new OffsetToColumnConverter())
@@ -27,38 +26,37 @@ function Debugger (options) {
   })
 
   this.breakPointManager = new remixLib.code.BreakpointManager(this.debugger, (sourceLocation) => {
-    return self.offsetToLineColumnConverter.offsetToLineColumn(sourceLocation, sourceLocation.file, this.compiler.lastCompilationResult.source.sources, this.compiler.lastCompilationResult.data.sources)
+    return this.offsetToLineColumnConverter.offsetToLineColumn(sourceLocation, sourceLocation.file, this.compiler.lastCompilationResult.source.sources, this.compiler.lastCompilationResult.data.sources)
   }, (step) => {
-    self.event.trigger('breakpointStep', [step])
+    this.event.trigger('breakpointStep', [step])
   })
 
   this.debugger.setBreakpointManager(this.breakPointManager)
 
-  this.debugger.event.register('newTraceLoaded', this, function () {
-    self.event.trigger('debuggerStatus', [true])
+  this.debugger.event.register('newTraceLoaded', this, () => {
+    this.event.trigger('debuggerStatus', [true])
   })
 
-  this.debugger.event.register('traceUnloaded', this, function () {
-    self.event.trigger('debuggerStatus', [false])
+  this.debugger.event.register('traceUnloaded', this, () => {
+    this.event.trigger('debuggerStatus', [false])
   })
 
-  this.event.register('breakpointStep', function (step) {
-    self.step_manager.jumpTo(step)
+  this.event.register('breakpointStep', (step) => {
+    this.step_manager.jumpTo(step)
   })
 }
 
 Debugger.prototype.registerAndHighlightCodeItem = function (index) {
-  const self = this
   // register selected code item, highlight the corresponding source location
-  if (!self.compiler.lastCompilationResult) return
-  self.debugger.traceManager.getCurrentCalledAddressAt(index, (error, address) => {
+  if (!this.compiler.lastCompilationResult) return
+  this.debugger.traceManager.getCurrentCalledAddressAt(index, (error, address) => {
     if (error) return console.log(error)
-    self.debugger.callTree.sourceLocationTracker.getSourceLocationFromVMTraceIndex(address, index, self.compiler.lastCompilationResult.data.contracts, function (error, rawLocation) {
-      if (!error && self.compiler.lastCompilationResult && self.compiler.lastCompilationResult.data) {
-        var lineColumnPos = self.offsetToLineColumnConverter.offsetToLineColumn(rawLocation, rawLocation.file, self.compiler.lastCompilationResult.source.sources, self.compiler.lastCompilationResult.data.sources)
-        self.event.trigger('newSourceLocation', [lineColumnPos, rawLocation])
+    this.debugger.callTree.sourceLocationTracker.getSourceLocationFromVMTraceIndex(address, index, this.compiler.lastCompilationResult.data.contracts, (error, rawLocation) => {
+      if (!error && this.compiler.lastCompilationResult && this.compiler.lastCompilationResult.data) {
+        var lineColumnPos = this.offsetToLineColumnConverter.offsetToLineColumn(rawLocation, rawLocation.file, this.compiler.lastCompilationResult.source.sources, this.compiler.lastCompilationResult.data.sources)
+        this.event.trigger('newSourceLocation', [lineColumnPos, rawLocation])
       } else {
-        self.event.trigger('newSourceLocation', [null])
+        this.event.trigger('newSourceLocation', [null])
       }
     })
   })
@@ -69,7 +67,7 @@ Debugger.prototype.updateWeb3 = function (web3) {
 }
 
 Debugger.prototype.debug = function (blockNumber, txNumber, tx, loadingCb) {
-  let web3 = this.debugger.web3
+  const web3 = this.debugger.web3
 
   return new Promise((resolve, reject) => {
     if (this.debugger.traceManager.isLoading) {
@@ -106,13 +104,12 @@ Debugger.prototype.debug = function (blockNumber, txNumber, tx, loadingCb) {
 }
 
 Debugger.prototype.debugTx = function (tx, loadingCb) {
-  const self = this
   this.step_manager = new StepManager(this.debugger, this.debugger.traceManager)
 
   this.debugger.codeManager.event.register('changed', this, (code, address, instIndex) => {
-    self.debugger.callTree.sourceLocationTracker.getSourceLocationFromVMTraceIndex(address, this.step_manager.currentStepIndex, this.debugger.solidityProxy.contracts, (error, sourceLocation) => {
+    this.debugger.callTree.sourceLocationTracker.getSourceLocationFromVMTraceIndex(address, this.step_manager.currentStepIndex, this.debugger.solidityProxy.contracts, (error, sourceLocation) => {
       if (!error) {
-        self.vmDebuggerLogic.event.trigger('sourceLocationChanged', [sourceLocation])
+        this.vmDebuggerLogic.event.trigger('sourceLocationChanged', [sourceLocation])
       }
     })
   })
@@ -120,16 +117,16 @@ Debugger.prototype.debugTx = function (tx, loadingCb) {
   this.vmDebuggerLogic = new VmDebuggerLogic(this.debugger, tx, this.step_manager, this.debugger.traceManager, this.debugger.codeManager, this.debugger.solidityProxy, this.debugger.callTree)
   this.vmDebuggerLogic.start()
 
-  this.step_manager.event.register('stepChanged', this, function (stepIndex) {
-    if (typeof stepIndex !== 'number' || stepIndex >= self.step_manager.traceLength) {
-      return self.event.trigger('endDebug')
+  this.step_manager.event.register('stepChanged', this, (stepIndex) => {
+    if (typeof stepIndex !== 'number' || stepIndex >= this.step_manager.traceLength) {
+      return this.event.trigger('endDebug')
     }
 
-    self.debugger.codeManager.resolveStep(stepIndex, tx)
-    self.step_manager.event.trigger('indexChanged', [stepIndex])
-    self.vmDebuggerLogic.event.trigger('indexChanged', [stepIndex])
-    self.vmDebuggerLogic.debugger.event.trigger('indexChanged', [stepIndex])
-    self.registerAndHighlightCodeItem(stepIndex)
+    this.debugger.codeManager.resolveStep(stepIndex, tx)
+    this.step_manager.event.trigger('indexChanged', [stepIndex])
+    this.vmDebuggerLogic.event.trigger('indexChanged', [stepIndex])
+    this.vmDebuggerLogic.debugger.event.trigger('indexChanged', [stepIndex])
+    this.registerAndHighlightCodeItem(stepIndex)
   })
 
   loadingCb()

remix-debug/src/debugger/solidityLocals.js

-var remixLib = require('remix-lib')
-var EventManager = remixLib.EventManager
+const remixLib = require('remix-lib')
+const EventManager = remixLib.EventManager
 
-var localDecoder = require('../solidity-decoder/localDecoder')
-var StorageViewer = require('../storage/storageViewer')
+const localDecoder = require('../solidity-decoder/localDecoder')
+const StorageViewer = require('../storage/storageViewer')
 
 class DebuggerSolidityLocals {
 
@@ -16,28 +16,26 @@ class DebuggerSolidityLocals {
   }
 
   init (sourceLocation) {
-    const self = this
     var decodeTimeout = null
     if (!this.storageResolver) {
-      return self.event.trigger('solidityLocalsMessage', ['storage not ready'])
+      return this.event.trigger('solidityLocalsMessage', ['storage not ready'])
     }
     if (decodeTimeout) {
       window.clearTimeout(decodeTimeout)
     }
-    self.event.trigger('solidityLocalsUpdating')
-    decodeTimeout = setTimeout(function () {
-      self.decode(sourceLocation)
+    this.event.trigger('solidityLocalsUpdating')
+    decodeTimeout = setTimeout(() => {
+      this.decode(sourceLocation)
     }, 500)
   }
 
   decode (sourceLocation) {
-    const self = this
-    self.event.trigger('solidityLocalsMessage', [''])
-    self.traceManager.waterfall([
-      self.traceManager.getStackAt,
-      self.traceManager.getMemoryAt,
-      self.traceManager.getCurrentCalledAddressAt],
-      self.stepManager.currentStepIndex,
+    this.event.trigger('solidityLocalsMessage', [''])
+    this.traceManager.waterfall([
+      this.traceManager.getStackAt,
+      this.traceManager.getMemoryAt,
+      this.traceManager.getCurrentCalledAddressAt],
+      this.stepManager.currentStepIndex,
       (error, result) => {
         if (error) {
           return error
@@ -45,17 +43,17 @@ class DebuggerSolidityLocals {
         var stack = result[0].value
         var memory = result[1].value
         try {
-          var storageViewer = new StorageViewer({ stepIndex: self.stepManager.currentStepIndex, tx: self.tx, address: result[2].value }, self.storageResolver, self.traceManager)
-          localDecoder.solidityLocals(self.stepManager.currentStepIndex, self.internalTreeCall, stack, memory, storageViewer, sourceLocation).then((locals) => {
+          var storageViewer = new StorageViewer({ stepIndex: this.stepManager.currentStepIndex, tx: this.tx, address: result[2].value }, this.storageResolver, this.traceManager)
+          localDecoder.solidityLocals(this.stepManager.currentStepIndex, this.internalTreeCall, stack, memory, storageViewer, sourceLocation).then((locals) => {
             if (!locals.error) {
-              self.event.trigger('solidityLocals', [locals])
+              this.event.trigger('solidityLocals', [locals])
             }
             if (!Object.keys(locals).length) {
-              self.event.trigger('solidityLocalsMessage', ['no locals'])
+              this.event.trigger('solidityLocalsMessage', ['no locals'])
             }
           })
         } catch (e) {
-          self.event.trigger('solidityLocalsMessage', [e.message])
+          this.event.trigger('solidityLocalsMessage', [e.message])
         }
       })
   }

remix-debug/src/debugger/solidityState.js

-var remixLib = require('remix-lib')
-var EventManager = remixLib.EventManager
-var stateDecoder = require('../solidity-decoder/stateDecoder')
-var StorageViewer = require('../storage/storageViewer')
+const remixLib = require('remix-lib')
+const EventManager = remixLib.EventManager
+const stateDecoder = require('../solidity-decoder/stateDecoder')
+const StorageViewer = require('../storage/storageViewer')
 
 class DebuggerSolidityState {
 
@@ -17,28 +17,27 @@ class DebuggerSolidityState {
   }
 
   init (index) {
-    var self = this
-    var decodeTimeout = null
+    let decodeTimeout = null
     if (index < 0) {
-      return self.event.trigger('solidityStateMessage', ['invalid step index'])
+      return this.event.trigger('solidityStateMessage', ['invalid step index'])
     }
 
-    if (self.stepManager.currentStepIndex !== index) return
-    if (!self.solidityProxy.loaded()) {
-      return self.event.trigger('solidityStateMessage', ['invalid step index'])
+    if (this.stepManager.currentStepIndex !== index) return
+    if (!this.solidityProxy.loaded()) {
+      return this.event.trigger('solidityStateMessage', ['invalid step index'])
     }
 
-    if (!self.storageResolver) {
+    if (!this.storageResolver) {
       return
     }
     if (decodeTimeout) {
       window.clearTimeout(decodeTimeout)
     }
-    self.event.trigger('solidityStateUpdating')
-    decodeTimeout = setTimeout(function () {
+    this.event.trigger('solidityStateUpdating')
+    decodeTimeout = setTimeout(() => {
       // necessary due to some states that can crash the debugger
       try {
-        self.decode(index)
+        this.decode(index)
       } catch (err) {
         console.dir('====> error')
         console.dir(err)
@@ -51,33 +50,31 @@ class DebuggerSolidityState {
   }
 
   decode (index) {
-    const self = this
-    self.traceManager.getCurrentCalledAddressAt(self.stepManager.currentStepIndex, function (error, address) {
+    this.traceManager.getCurrentCalledAddressAt(this.stepManager.currentStepIndex, (error, address) => {
       if (error) {
-        return self.event.trigger('solidityState', [{}])
+        return this.event.trigger('solidityState', [{}])
       }
-      if (self.stateVariablesByAddresses[address]) {
-        return self.extractStateVariables(self.stateVariablesByAddresses[address], address)
+      if (this.stateVariablesByAddresses[address]) {
+        return this.extractStateVariables(this.stateVariablesByAddresses[address], address)
       }
-      self.solidityProxy.extractStateVariablesAt(index, function (error, stateVars) {
+      this.solidityProxy.extractStateVariablesAt(index, (error, stateVars) => {
         if (error) {
-          return self.event.trigger('solidityState', [{}])
+          return this.event.trigger('solidityState', [{}])
         }
-        self.stateVariablesByAddresses[address] = stateVars
-        self.extractStateVariables(stateVars, address)
+        this.stateVariablesByAddresses[address] = stateVars
+        this.extractStateVariables(stateVars, address)
       })
     })
   }
 
   extractStateVariables (stateVars, address) {
-    const self = this
-    var storageViewer = new StorageViewer({ stepIndex: self.stepManager.currentStepIndex, tx: self.tx, address: address }, self.storageResolver, self.traceManager)
+    var storageViewer = new StorageViewer({ stepIndex: this.stepManager.currentStepIndex, tx: this.tx, address: address }, this.storageResolver, this.traceManager)
     stateDecoder.decodeState(stateVars, storageViewer).then((result) => {
-      self.event.trigger('solidityStateMessage', [''])
+      this.event.trigger('solidityStateMessage', [''])
       if (result.error) {
-        return self.event.trigger('solidityStateMessage', [result.error])
+        return this.event.trigger('solidityStateMessage', [result.error])
       }
-      self.event.trigger('solidityState', [result])
+      this.event.trigger('solidityState', [result])
     })
   }
 

remix-debug/src/debugger/stepManager.js

-var remixLib = require('remix-lib')
-var EventManager = remixLib.EventManager
-var util = remixLib.util
+const remixLib = require('remix-lib')
+const EventManager = remixLib.EventManager
+const util = remixLib.util
 
 class DebuggerStepManager {
 
@@ -17,57 +17,54 @@ class DebuggerStepManager {
   }
 
   listenToEvents () {
-    const self = this
-
-    this.debugger.event.register('newTraceLoaded', this, function () {
-      self.traceManager.getLength(function (error, newLength) {
+    this.debugger.event.register('newTraceLoaded', this, () => {
+      this.traceManager.getLength((error, newLength) => {
         if (error) {
           return console.log(error)
         }
-        if (self.traceLength !== newLength) {
-          self.event.trigger('traceLengthChanged', [newLength])
-          self.traceLength = newLength
-          self.codeTraceLength = self.calculateCodeLength()
+        if (this.traceLength !== newLength) {
+          this.event.trigger('traceLengthChanged', [newLength])
+          this.traceLength = newLength
+          this.codeTraceLength = this.calculateCodeLength()
         }
-        self.jumpTo(0)
+        this.jumpTo(0)
       })
     })
 
     this.debugger.callTree.event.register('callTreeReady', () => {
-      if (self.debugger.callTree.functionCallStack.length) {
-        self.jumpTo(self.debugger.callTree.functionCallStack[0])
+      if (this.debugger.callTree.functionCallStack.length) {
+        this.jumpTo(this.debugger.callTree.functionCallStack[0])
       }
     })
 
     this.event.register('indexChanged', this, (index) => {
       if (index < 0) return
-      if (self.currentStepIndex !== index) return
+      if (this.currentStepIndex !== index) return
 
-      self.traceManager.buildCallPath(index, (error, callsPath) => {
+      this.traceManager.buildCallPath(index, (error, callsPath) => {
         if (error) {
           console.log(error)
-          return self.event.trigger('revertWarning', [''])
+          return this.event.trigger('revertWarning', [''])
         }
-        self.currentCall = callsPath[callsPath.length - 1]
-        if (self.currentCall.reverted) {
-          let revertedReason = self.currentCall.outofgas ? 'outofgas' : ''
-          self.revertionPoint = self.currentCall.return
-          return self.event.trigger('revertWarning', [revertedReason])
+        this.currentCall = callsPath[callsPath.length - 1]
+        if (this.currentCall.reverted) {
+          let revertedReason = this.currentCall.outofgas ? 'outofgas' : ''
+          this.revertionPoint = this.currentCall.return
+          return this.event.trigger('revertWarning', [revertedReason])
         }
         for (var k = callsPath.length - 2; k >= 0; k--) {
           var parent = callsPath[k]
           if (!parent.reverted) continue
-          self.revertionPoint = parent.return
-          self.event.trigger('revertWarning', ['parenthasthrown'])
+          this.revertionPoint = parent.return
+          this.event.trigger('revertWarning', ['parenthasthrown'])
         }
-        self.event.trigger('revertWarning', [''])
+        this.event.trigger('revertWarning', [''])
       })
     })
   }
 
   triggerStepChanged (step) {
-    const self = this
-    this.traceManager.getLength(function (error, length) {
+    this.traceManager.getLength((error, length) => {
       let stepState = 'valid'
 
       if (error) {
@@ -78,15 +75,15 @@ class DebuggerStepManager {
         stepState = 'end'
       }
 
-      let jumpOutDisabled = (step === self.traceManager.findStepOut(step))
+      let jumpOutDisabled = (step === this.traceManager.findStepOut(step))
 
-      self.event.trigger('stepChanged', [step, stepState, jumpOutDisabled])
+      this.event.trigger('stepChanged', [step, stepState, jumpOutDisabled])
     })
   }
 
   stepIntoBack (solidityMode) {
     if (!this.traceManager.isLoaded()) return
-    var step = this.currentStepIndex - 1
+    let step = this.currentStepIndex - 1
     this.currentStepIndex = step
     if (solidityMode) {
       step = this.resolveToReducedTrace(step, -1)
@@ -99,7 +96,7 @@ class DebuggerStepManager {
 
   stepIntoForward (solidityMode) {
     if (!this.traceManager.isLoaded()) return
-    var step = this.currentStepIndex + 1
+    let step = this.currentStepIndex + 1
     this.currentStepIndex = step
     if (solidityMode) {
       step = this.resolveToReducedTrace(step, 1)
@@ -112,7 +109,7 @@ class DebuggerStepManager {
 
   stepOverBack (solidityMode) {
     if (!this.traceManager.isLoaded()) return
-    var step = this.traceManager.findStepOverBack(this.currentStepIndex)
+    let step = this.traceManager.findStepOverBack(this.currentStepIndex)
     if (solidityMode) {
       step = this.resolveToReducedTrace(step, -1)
     }
@@ -122,7 +119,7 @@ class DebuggerStepManager {
 
   stepOverForward (solidityMode) {
     if (!this.traceManager.isLoaded()) return
-    var step = this.currentStepIndex + 1
+    let step = this.currentStepIndex + 1
     let scope = this.debugger.callTree.findScope(step)
     if (scope && scope.firstStep === step) {
       step = scope.lastStep + 1

remix-debug/src/solidity-decoder/astHelper.js

 'use strict'
-var remixLib = require('remix-lib')
-var AstWalker = remixLib.AstWalker
+const remixLib = require('remix-lib')
+const AstWalker = remixLib.AstWalker
 
 /**
   * return all contract definitions of the given @astList
@@ -9,14 +9,14 @@ var AstWalker = remixLib.AstWalker
   * @return {Object} - returns a mapping from AST node ids to AST nodes for the contracts
   */
 function extractContractDefinitions (sourcesList) {
-  var ret = {
+  const ret = {
     contractsById: {},
     contractsByName: {},
     sourcesByContract: {}
   }
-  var walker = new AstWalker()
-  for (var k in sourcesList) {
-    walker.walk(sourcesList[k].legacyAST, { 'ContractDefinition': function (node) {
+  const walker = new AstWalker()
+  for (let k in sourcesList) {
+    walker.walk(sourcesList[k].legacyAST, { 'ContractDefinition': (node) => {
       ret.contractsById[node.id] = node
       ret.sourcesByContract[node.id] = k
       ret.contractsByName[k + ':' + node.attributes.name] = node
@@ -50,16 +50,16 @@ function extractStateDefinitions (contractName, sourcesList, contracts) {
   if (!contracts) {
     contracts = extractContractDefinitions(sourcesList)
   }
-  var node = contracts.contractsByName[contractName]
+  const node = contracts.contractsByName[contractName]
   if (node) {
-    var stateItems = []
-    var stateVar = []
-    var baseContracts = getLinearizedBaseContracts(node.id, contracts.contractsById)
+    const stateItems = []
+    const stateVar = []
+    const baseContracts = getLinearizedBaseContracts(node.id, contracts.contractsById)
     baseContracts.reverse()
-    for (var k in baseContracts) {
-      var ctr = baseContracts[k]
-      for (var i in ctr.children) {
-        var item = ctr.children[i]
+    for (let k in baseContracts) {
+      const ctr = baseContracts[k]
+      for (let i in ctr.children) {
+        const item = ctr.children[i]
         stateItems.push(item)
         if (item.name === 'VariableDeclaration') {
           stateVar.push(item)
@@ -85,12 +85,12 @@ function extractStatesDefinitions (sourcesList, contracts) {
   if (!contracts) {
     contracts = extractContractDefinitions(sourcesList)
   }
-  var ret = {}
-  for (var contract in contracts.contractsById) {
-    var name = contracts.contractsById[contract].attributes.name
-    var source = contracts.sourcesByContract[contract]
-    var fullName = source + ':' + name
-    var state = extractStateDefinitions(fullName, sourcesList, contracts)
+  const ret = {}
+  for (let contract in contracts.contractsById) {
+    const name = contracts.contractsById[contract].attributes.name
+    const source = contracts.sourcesByContract[contract]
+    const fullName = source + ':' + name
+    const state = extractStateDefinitions(fullName, sourcesList, contracts)
     ret[fullName] = state
     ret[name] = state // solc < 0.4.9
   }

remix-debug/src/solidity-decoder/decodeInfo.js

 'use strict'
 
-var AddressType = require('./types/Address')
-var ArrayType = require('./types/ArrayType')
-var BoolType = require('./types/Bool')
-var BytesType = require('./types/DynamicByteArray')
-var BytesXType = require('./types/FixedByteArray')
-var EnumType = require('./types/Enum')
-var StringType = require('./types/StringType')
-var StructType = require('./types/Struct')
-var IntType = require('./types/Int')
-var UintType = require('./types/Uint')
-var MappingType = require('./types/Mapping')
-var util = require('./types/util')
+const AddressType = require('./types/Address')
+const ArrayType = require('./types/ArrayType')
+const BoolType = require('./types/Bool')
+const BytesType = require('./types/DynamicByteArray')
+const BytesXType = require('./types/FixedByteArray')
+const EnumType = require('./types/Enum')
+const StringType = require('./types/StringType')
+const StructType = require('./types/Struct')
+const IntType = require('./types/Int')
+const UintType = require('./types/Uint')
+const MappingType = require('./types/Mapping')
+const util = require('./types/util')
 
 /**
   * mapping decode the given @arg type
@@ -20,12 +20,12 @@ var util = require('./types/util')
   * @return {Object} returns decoded info about the current type: { storageBytes, typeName}
   */
 function mapping (type, stateDefinitions, contractName) {
-  var match = type.match(/mapping\((.*?)=>(.*)\)$/)
-  var keyTypeName = match[1].trim()
-  var valueTypeName = match[2].trim()
+  const match = type.match(/mapping\((.*?)=>(.*)\)$/)
+  const keyTypeName = match[1].trim()
+  const valueTypeName = match[2].trim()
 
-  var keyType = parseType(keyTypeName, stateDefinitions, contractName, 'storage')
-  var valueType = parseType(valueTypeName, stateDefinitions, contractName, 'storage')
+  const keyType = parseType(keyTypeName, stateDefinitions, contractName, 'storage')
+  const valueType = parseType(valueTypeName, stateDefinitions, contractName, 'storage')
 
   var underlyingTypes = {
     'keyType': keyType,
@@ -42,7 +42,7 @@ function mapping (type, stateDefinitions, contractName) {
   */
 function uint (type) {
   type === 'uint' ? 'uint256' : type
-  var storageBytes = parseInt(type.replace('uint', '')) / 8
+  const storageBytes = parseInt(type.replace('uint', '')) / 8
   return new UintType(storageBytes)
 }
 
@@ -54,7 +54,7 @@ function uint (type) {
   */
 function int (type) {
   type === 'int' ? 'int256' : type
-  var storageBytes = parseInt(type.replace('int', '')) / 8
+  const storageBytes = parseInt(type.replace('int', '')) / 8
   return new IntType(storageBytes)
 }
 
@@ -105,7 +105,7 @@ function dynamicByteArray (type, stateDefinitions, contractName, location) {
   * @return {Object} returns decoded info about the current type: { storageBytes, typeName}
   */
 function fixedByteArray (type) {
-  var storageBytes = parseInt(type.replace('bytes', ''))
+  const storageBytes = parseInt(type.replace('bytes', ''))
   return new BytesXType(storageBytes)
 }
 
@@ -139,8 +139,8 @@ function stringType (type, stateDefinitions, contractName, location) {
   * @return {Object} returns decoded info about the current type: { storageBytes, typeName, arraySize, subArray}
   */
 function array (type, stateDefinitions, contractName, location) {
-  var arraySize
-  var match = type.match(/(.*)\[(.*?)\]( storage ref| storage pointer| memory| calldata)?$/)
+  let arraySize
+  const match = type.match(/(.*)\[(.*?)\]( storage ref| storage pointer| memory| calldata)?$/)
   if (!match) {
     console.log('unable to parse type ' + type)
     return null
@@ -149,7 +149,7 @@ function array (type, stateDefinitions, contractName, location) {
     location = match[3].trim()
   }
   arraySize = match[2] === '' ? 'dynamic' : parseInt(match[2])
-  var underlyingType = parseType(match[1], stateDefinitions, contractName, location)
+  const underlyingType = parseType(match[1], stateDefinitions, contractName, location)
   if (underlyingType === null) {
     console.log('unable to parse type ' + type)
     return null
@@ -166,8 +166,8 @@ function array (type, stateDefinitions, contractName, location) {
   * @return {Object} returns decoded info about the current type: { storageBytes, typeName, enum}
   */
 function enumType (type, stateDefinitions, contractName) {
-  var match = type.match(/enum (.*)/)
-  var enumDef = getEnum(match[1], stateDefinitions, contractName)
+  const match = type.match(/enum (.*)/)
+  const enumDef = getEnum(match[1], stateDefinitions, contractName)
   if (enumDef === null) {
     console.log('unable to retrieve decode info of ' + type)
     return null
@@ -185,12 +185,12 @@ function enumType (type, stateDefinitions, contractName) {
   * @return {Object} returns decoded info about the current type: { storageBytes, typeName, members}
   */
 function struct (type, stateDefinitions, contractName, location) {
-  var match = type.match(/struct (\S*?)( storage ref| storage pointer| memory| calldata)?$/)
+  const match = type.match(/struct (\S*?)( storage ref| storage pointer| memory| calldata)?$/)
   if (match) {
     if (!location) {
       location = match[2].trim()
     }
-    var memberDetails = getStructMembers(match[1], stateDefinitions, contractName, location) // type is used to extract the ast struct definition
+    const memberDetails = getStructMembers(match[1], stateDefinitions, contractName, location) // type is used to extract the ast struct definition
     if (!memberDetails) return null
     return new StructType(memberDetails, location, match[1])
   } else {
@@ -207,15 +207,15 @@ function struct (type, stateDefinitions, contractName, location) {
   * @return {Array} - containing all value declaration of the current enum type
   */
 function getEnum (type, stateDefinitions, contractName) {
-  var split = type.split('.')
+  const split = type.split('.')
   if (!split.length) {
     type = contractName + '.' + type
   } else {
     contractName = split[0]
   }
-  var state = stateDefinitions[contractName]
+  const state = stateDefinitions[contractName]
   if (state) {
-    for (var dec of state.stateDefinitions) {
+    for (let dec of state.stateDefinitions) {
       if (dec.attributes && dec.attributes.name && type === contractName + '.' + dec.attributes.name) {
         return dec
       }
@@ -234,17 +234,17 @@ function getEnum (type, stateDefinitions, contractName) {
   * @return {Array} containing all members of the current struct type
   */
 function getStructMembers (type, stateDefinitions, contractName, location) {
-  var split = type.split('.')
+  const split = type.split('.')
   if (!split.length) {
     type = contractName + '.' + type
   } else {
     contractName = split[0]
   }
-  var state = stateDefinitions[contractName]
+  const state = stateDefinitions[contractName]
   if (state) {
-    for (var dec of state.stateDefinitions) {
+    for (let dec of state.stateDefinitions) {
       if (dec.name === 'StructDefinition' && type === contractName + '.' + dec.attributes.name) {
-        var offsets = computeOffsets(dec.children, stateDefinitions, contractName, location)
+        const offsets = computeOffsets(dec.children, stateDefinitions, contractName, location)
         if (!offsets) {
           return null
         }
@@ -275,7 +275,7 @@ function typeClass (fullType) {
   if (fullType.indexOf(' ') !== -1) {
     fullType = fullType.split(' ')[0]
   }
-  var char = fullType.indexOf('bytes') === 0 ? 'X' : ''
+  const char = fullType.indexOf('bytes') === 0 ? 'X' : ''
   return fullType.replace(/[0-9]+/g, char)
 }
 
@@ -289,7 +289,7 @@ function typeClass (fullType) {
   * @return {Object} - return the corresponding decoder or null on error
   */
 function parseType (type, stateDefinitions, contractName, location) {
-  var decodeInfos = {
+  const decodeInfos = {
     'contract': address,
     'address': address,
     'array': array,
@@ -303,7 +303,7 @@ function parseType (type, stateDefinitions, contractName, location) {
     'uint': uint,
     'mapping': mapping
   }
-  var currentType = typeClass(type)
+  const currentType = typeClass(type)
   if (currentType === null) {
     console.log('unable to retrieve decode info of ' + type)
     return null
@@ -325,8 +325,8 @@ function parseType (type, stateDefinitions, contractName, location) {
   * @return {Array} - return an array of types item: {name, type, location}. location defines the byte offset and slot offset
   */
 function computeOffsets (types, stateDefinitions, contractName, location) {
-  var ret = []
-  var storagelocation = {
+  const ret = []
+  const storagelocation = {
     offset: 0,
     slot: 0
   }

remix-debug/src/solidity-decoder/index.js

-var SolidityProxy = require('./solidityProxy')
-var stateDecoder = require('./stateDecoder')
-var localDecoder = require('./localDecoder')
-var InternalCallTree = require('./internalCallTree')
+const SolidityProxy = require('./solidityProxy')
+const stateDecoder = require('./stateDecoder')
+const localDecoder = require('./localDecoder')
+const InternalCallTree = require('./internalCallTree')
 
 module.exports = {
   SolidityProxy: SolidityProxy,

remix-debug/src/solidity-decoder/internalCallTree.js

 'use strict'
-var remixLib = require('remix-lib')
-var SourceLocationTracker = remixLib.SourceLocationTracker
-var AstWalker = remixLib.AstWalker
-var EventManager = remixLib.EventManager
-var decodeInfo = require('./decodeInfo')
-var util = remixLib.util
-var traceHelper = remixLib.helpers.trace
-var typesUtil = require('./types/util.js')
+const remixLib = require('remix-lib')
+const SourceLocationTracker = remixLib.SourceLocationTracker
+const AstWalker = remixLib.AstWalker
+const EventManager = remixLib.EventManager
+const decodeInfo = require('./decodeInfo')
+const util = remixLib.util
+const traceHelper = remixLib.helpers.trace
+const typesUtil = require('./types/util.js')
 
 /**
  * Tree representing internal jump into function.
@@ -79,15 +79,15 @@ class InternalCallTree {
     * @param {Int} vmtraceIndex  - index on the vm trace
     */
   findScope (vmtraceIndex) {
-    var scopes = Object.keys(this.scopeStarts)
+    const scopes = Object.keys(this.scopeStarts)
     if (!scopes.length) {
       return null
     }
-    var scopeId = util.findLowerBoundValue(vmtraceIndex, scopes)
+    let scopeId = util.findLowerBoundValue(vmtraceIndex, scopes)
     scopeId = this.scopeStarts[scopeId]
-    var scope = this.scopes[scopeId]
+    let scope = this.scopes[scopeId]
     while (scope.lastStep && scope.lastStep < vmtraceIndex && scope.firstStep > 0) {
-      var matched = scopeId.match(/(.\d|\d)$/)
+      const matched = scopeId.match(/(.\d|\d)$/)
       scopeId = scopeId.replace(matched[1], '')
       scope = this.scopes[scopeId]
     }
@@ -95,11 +95,10 @@ class InternalCallTree {
   }
 
   extractSourceLocation (step) {
-    var self = this
-    return new Promise(function (resolve, reject) {
-      self.traceManager.getCurrentCalledAddressAt(step, (error, address) => {
+    return new Promise((resolve, reject) => {
+      this.traceManager.getCurrentCalledAddressAt(step, (error, address) => {
         if (!error) {
-          self.sourceLocationTracker.getSourceLocationFromVMTraceIndex(address, step, self.solidityProxy.contracts, (error, sourceLocation) => {
+          this.sourceLocationTracker.getSourceLocationFromVMTraceIndex(address, step, this.solidityProxy.contracts, (error, sourceLocation) => {
             if (!error) {
               return resolve(sourceLocation)
             } else {
@@ -135,11 +134,11 @@ async function buildTree (tree, step, scopeId, isExternalCall) {
         included.file === source.file)
   }
 
-  var currentSourceLocation = {start: -1, length: -1, file: -1}
-  var previousSourceLocation = currentSourceLocation
+  let currentSourceLocation = {start: -1, length: -1, file: -1}
+  let previousSourceLocation = currentSourceLocation
   while (step < tree.traceManager.trace.length) {
-    var sourceLocation
-    var newLocation = false
+    let sourceLocation
+    let newLocation = false
     try {
       sourceLocation = await tree.extractSourceLocation(step)
       if (!includedSource(sourceLocation, currentSourceLocation)) {
@@ -153,11 +152,11 @@ async function buildTree (tree, step, scopeId, isExternalCall) {
     if (!sourceLocation) {
       return { outStep: step, error: 'InternalCallTree - No source Location. ' + step }
     }
-    var isCallInstruction = traceHelper.isCallInstruction(tree.traceManager.trace[step])
+    const isCallInstruction = traceHelper.isCallInstruction(tree.traceManager.trace[step])
     // we are checking if we are jumping in a new CALL or in an internal function
     if (isCallInstruction || sourceLocation.jump === 'i') {
       try {
-        var externalCallResult = await buildTree(tree, step + 1, scopeId === '' ? subScope.toString() : scopeId + '.' + subScope, isCallInstruction)
+        const externalCallResult = await buildTree(tree, step + 1, scopeId === '' ? subScope.toString() : scopeId + '.' + subScope, isCallInstruction)
         if (externalCallResult.error) {
           return { outStep: step, error: 'InternalCallTree - ' + externalCallResult.error }
         } else {
@@ -190,7 +189,7 @@ function createReducedTrace (tree, index) {
 }
 
 function includeVariableDeclaration (tree, step, sourceLocation, scopeId, newLocation, previousSourceLocation) {
-  var variableDeclaration = resolveVariableDeclaration(tree, step, sourceLocation)
+  const variableDeclaration = resolveVariableDeclaration(tree, step, sourceLocation)
   // using the vm trace step, the current source location and the ast,
   // we check if the current vm trace step target a new ast node of type VariableDeclaration
   // that way we know that there is a new local variable from here.
@@ -218,7 +217,7 @@ function includeVariableDeclaration (tree, step, sourceLocation, scopeId, newLoc
   }
   // we check here if we are at the beginning inside a new function.
   // if that is the case, we have to add to locals tree the inputs and output params
-  var functionDefinition = resolveFunctionDefinition(tree, step, previousSourceLocation)
+  const functionDefinition = resolveFunctionDefinition(tree, step, previousSourceLocation)
   if (functionDefinition && (newLocation && traceHelper.isJumpDestInstruction(tree.traceManager.trace[step - 1]) || functionDefinition.attributes.isConstructor)) {
     tree.functionCallStack.push(step)
     // means: the previous location was a function definition && JUMPDEST
@@ -243,7 +242,7 @@ function includeVariableDeclaration (tree, step, sourceLocation, scopeId, newLoc
 // and keep this in a cache
 function resolveVariableDeclaration (tree, step, sourceLocation) {
   if (!tree.variableDeclarationByFile[sourceLocation.file]) {
-    var ast = tree.solidityProxy.ast(sourceLocation)
+    const ast = tree.solidityProxy.ast(sourceLocation)
     if (ast) {
       tree.variableDeclarationByFile[sourceLocation.file] = extractVariableDeclarations(ast, tree.astWalker)
     } else {
@@ -258,7 +257,7 @@ function resolveVariableDeclaration (tree, step, sourceLocation) {
 // and keep this in a cache
 function resolveFunctionDefinition (tree, step, sourceLocation) {
   if (!tree.functionDefinitionByFile[sourceLocation.file]) {
-    var ast = tree.solidityProxy.ast(sourceLocation)
+    const ast = tree.solidityProxy.ast(sourceLocation)
     if (ast) {
       tree.functionDefinitionByFile[sourceLocation.file] = extractFunctionDefinitions(ast, tree.astWalker)
     } else {
@@ -270,7 +269,7 @@ function resolveFunctionDefinition (tree, step, sourceLocation) {
 }
 
 function extractVariableDeclarations (ast, astWalker) {
-  var ret = {}
+  const ret = {}
   astWalker.walk(ast, (node) => {
     if (node.name === 'VariableDeclaration') {
       ret[node.src] = node
@@ -281,7 +280,7 @@ function extractVariableDeclarations (ast, astWalker) {
 }
 
 function extractFunctionDefinitions (ast, astWalker) {
-  var ret = {}
+  const ret = {}
   astWalker.walk(ast, (node) => {
     if (node.name === 'FunctionDefinition') {
       ret[node.src] = node
@@ -292,11 +291,11 @@ function extractFunctionDefinitions (ast, astWalker) {
 }
 
 function addParams (parameterList, tree, scopeId, states, contractName, sourceLocation, stackLength, stackPosition, dir) {
-  for (var inputParam in parameterList.children) {
-    var param = parameterList.children[inputParam]
-    var stackDepth = stackLength + (dir * stackPosition)
+  for (let inputParam in parameterList.children) {
+    const param = parameterList.children[inputParam]
+    const stackDepth = stackLength + (dir * stackPosition)
     if (stackDepth >= 0) {
-      var location = typesUtil.extractLocationFromAstVariable(param)
+      let location = typesUtil.extractLocationFromAstVariable(param)
       location = location === 'default' ? 'memory' : location
       tree.scopes[scopeId].locals[param.attributes.name] = {
         name: param.attributes.name,

remix-debug/src/solidity-decoder/localDecoder.js

 'use strict'
 
 async function solidityLocals (vmtraceIndex, internalTreeCall, stack, memory, storageResolver, currentSourceLocation) {
-  var scope = internalTreeCall.findScope(vmtraceIndex)
+  const scope = internalTreeCall.findScope(vmtraceIndex)
   if (!scope) {
-    var error = { 'message': 'Can\'t display locals. reason: compilation result might not have been provided' }
+    const error = { 'message': 'Can\'t display locals. reason: compilation result might not have been provided' }
     throw error
   }
-  var locals = {}
+  const locals = {}
   memory = formatMemory(memory)
-  var anonymousIncr = 1
-  for (var local in scope.locals) {
-    var variable = scope.locals[local]
+  let anonymousIncr = 1
+  for (let local in scope.locals) {
+    const variable = scope.locals[local]
     if (variable.stackDepth < stack.length && variable.sourceLocation.start <= currentSourceLocation.start) {
-      var name = variable.name
+      let name = variable.name
       if (name === '') {
         name = '<' + anonymousIncr + '>'
         anonymousIncr++

remix-debug/src/solidity-decoder/solidityProxy.js

 'use strict'
-var remixLib = require('remix-lib')
-var traceHelper = remixLib.helpers.trace
-var stateDecoder = require('./stateDecoder')
-var astHelper = require('./astHelper')
-var util = remixLib.util
+const remixLib = require('remix-lib')
+const traceHelper = remixLib.helpers.trace
+const stateDecoder = require('./stateDecoder')
+const astHelper = require('./astHelper')
+const util = remixLib.util
 
 class SolidityProxy {
   constructor (traceManager, codeManager) {
@@ -51,7 +51,7 @@ class SolidityProxy {
             if (error) {
               cb(error)
             } else {
-              var contractName = contractNameFromCode(this.contracts, code.bytecode, address)
+              const contractName = contractNameFromCode(this.contracts, code.bytecode, address)
               this.cache.contractNameByAddress[address] = contractName
               cb(null, contractName)
             }
@@ -113,7 +113,7 @@ class SolidityProxy {
     * @return {Object} - AST of the current file
     */
   ast (sourceLocation) {
-    var file = this.fileNameFromIndex(sourceLocation.file)
+    const file = this.fileNameFromIndex(sourceLocation.file)
     if (this.sources[file]) {
       return this.sources[file].legacyAST
     } else {
@@ -134,10 +134,10 @@ class SolidityProxy {
 }
 
 function contractNameFromCode (contracts, code, address) {
-  var isCreation = traceHelper.isContractCreation(address)
-  for (var file in contracts) {
-    for (var contract in contracts[file]) {
-      var bytecode = isCreation ? contracts[file][contract].evm.bytecode.object : contracts[file][contract].evm.deployedBytecode.object
+  const isCreation = traceHelper.isContractCreation(address)
+  for (let file in contracts) {
+    for (let contract in contracts[file]) {
+      const bytecode = isCreation ? contracts[file][contract].evm.bytecode.object : contracts[file][contract].evm.deployedBytecode.object
       if (util.compareByteCode(code, '0x' + bytecode)) {
         return contract
       }

remix-debug/src/solidity-decoder/stateDecoder.js

-var astHelper = require('./astHelper')
-var decodeInfo = require('./decodeInfo')
+const astHelper = require('./astHelper')
+const decodeInfo = require('./decodeInfo')
 
 /**
   * decode the contract state storage
@@ -9,11 +9,11 @@ var decodeInfo = require('./decodeInfo')
   * @return {Map} - decoded state variable
   */
 async function decodeState (stateVars, storageResolver) {
-  var ret = {}
+  const ret = {}
   for (var k in stateVars) {
-    var stateVar = stateVars[k]
+    const stateVar = stateVars[k]
     try {
-      var decoded = await stateVar.type.decodeFromStorage(stateVar.storagelocation, storageResolver)
+      const decoded = await stateVar.type.decodeFromStorage(stateVar.storagelocation, storageResolver)
       decoded.constant = stateVar.constant
       if (decoded.constant) {
         decoded.value = '<constant>'
@@ -35,12 +35,12 @@ async function decodeState (stateVars, storageResolver) {
   * @return {Object} - return the location of all contract variables in the storage
   */
 function extractStateVariables (contractName, sourcesList) {
-  var states = astHelper.extractStatesDefinitions(sourcesList)
+  const states = astHelper.extractStatesDefinitions(sourcesList)
   if (!states[contractName]) {
     return []
   }
-  var types = states[contractName].stateVariables
-  var offsets = decodeInfo.computeOffsets(types, states, contractName, 'storage')
+  const types = states[contractName].stateVariables
+  const offsets = decodeInfo.computeOffsets(types, states, contractName, 'storage')
   if (!offsets) {
     return [] // TODO should maybe return an error
   }
@@ -56,7 +56,7 @@ function extractStateVariables (contractName, sourcesList) {
   * @return {Map} - return the state of the contract
   */
 async function solidityState (storageResolver, astList, contractName) {
-  var stateVars = extractStateVariables(contractName, astList)
+  const stateVars = extractStateVariables(contractName, astList)
   try {
     return await decodeState(stateVars, storageResolver)
   } catch (e) {

remix-debug/src/solidity-decoder/types/Address.js

 'use strict'
-var util = require('./util')
-var ValueType = require('./ValueType')
+const util = require('./util')
+const ValueType = require('./ValueType')
 
 class Address extends ValueType {
   constructor () {

remix-debug/src/solidity-decoder/types/ArrayType.js

 'use strict'
-var util = require('./util')
-var remixLib = require('remix-lib')
-var sha3256 = remixLib.util.sha3_256
-var BN = require('ethereumjs-util').BN
-var RefType = require('./RefType')
+const util = require('./util')
+const remixLib = require('remix-lib')
+const sha3256 = remixLib.util.sha3_256
+const BN = require('ethereumjs-util').BN
+const RefType = require('./RefType')
 
 class ArrayType extends RefType {
 
   constructor (underlyingType, arraySize, location) {
-    var storageSlots = null
+    let storageSlots = null
     if (arraySize === 'dynamic') {
       storageSlots = 1
     } else {
       if (underlyingType.storageBytes < 32) {
-        var itemPerSlot = Math.floor(32 / underlyingType.storageBytes)
+        const itemPerSlot = Math.floor(32 / underlyingType.storageBytes)
         storageSlots = Math.ceil(arraySize / itemPerSlot)
       } else {
         storageSlots = arraySize * underlyingType.storageSlots
       }
     }
-    var size = arraySize !== 'dynamic' ? arraySize : ''
+    const size = arraySize !== 'dynamic' ? arraySize : ''
     super(storageSlots, 32, underlyingType.typeName + '[' + size + ']', location)
     this.underlyingType = underlyingType
     this.arraySize = arraySize
   }
 
   async decodeFromStorage (location, storageResolver) {
-    var ret = []
-    var size = null
-    var slotValue
+    const ret = []
+    let size = null
+    let slotValue
     try {
       slotValue = await util.extractHexValue(location, storageResolver, this.storageBytes)
     } catch (e) {
@@ -38,7 +38,7 @@ class ArrayType extends RefType {
         type: this.typeName
       }
     }
-    var currentLocation = {
+    const currentLocation = {
       offset: 0,
       slot: location.slot
     }
@@ -77,8 +77,8 @@ class ArrayType extends RefType {
   }
 
   decodeFromMemoryInternal (offset, memory) {
-    var ret = []
-    var length = this.arraySize
+    const ret = []
+    let length = this.arraySize
     if (this.arraySize === 'dynamic') {
       length = memory.substr(2 * offset, 64)
       length = parseInt(length, 16)

remix-debug/src/solidity-decoder/types/Bool.js

 'use strict'
-var ValueType = require('./ValueType')
-var util = require('./util')
+const ValueType = require('./ValueType')
+const util = require('./util')
 
 class Bool extends ValueType {
   constructor () {

remix-debug/src/solidity-decoder/types/DynamicByteArray.js

 'use strict'
-var util = require('./util')
-var remixLib = require('remix-lib')
-var sha3256 = remixLib.util.sha3_256
-var BN = require('ethereumjs-util').BN
-var RefType = require('./RefType')
+const util = require('./util')
+const remixLib = require('remix-lib')
+const sha3256 = remixLib.util.sha3_256
+const BN = require('ethereumjs-util').BN
+const RefType = require('./RefType')
 
 class DynamicByteArray extends RefType {
   constructor (location) {
@@ -11,7 +11,7 @@ class DynamicByteArray extends RefType {
   }
 
   async decodeFromStorage (location, storageResolver) {
-    var value = '0x0'
+    let value = '0x0'
     try {
       value = await util.extractHexValue(location, storageResolver, this.storageBytes)
     } catch (e) {
@@ -21,12 +21,12 @@ class DynamicByteArray extends RefType {
         type: this.typeName
       }
     }
-    var bn = new BN(value, 16)
+    const bn = new BN(value, 16)
     if (bn.testn(0)) {
-      var length = bn.div(new BN(2))
-      var dataPos = new BN(sha3256(location.slot).replace('0x', ''), 16)
-      var ret = ''
-      var currentSlot = '0x'
+      const length = bn.div(new BN(2))
+      let dataPos = new BN(sha3256(location.slot).replace('0x', ''), 16)
+      let ret = ''
+      let currentSlot = '0x'
       try {
         currentSlot = await util.readFromStorage(dataPos, storageResolver)
       } catch (e) {
@@ -67,7 +67,7 @@ class DynamicByteArray extends RefType {
 
   decodeFromMemoryInternal (offset, memory) {
     offset = 2 * offset
-    var length = memory.substr(offset, 64)
+    let length = memory.substr(offset, 64)
     length = 2 * parseInt(length, 16)
     return {
       length: '0x' + length.toString(16),

remix-debug/src/solidity-decoder/types/Enum.js

 'use strict'
-var ValueType = require('./ValueType')
+const ValueType = require('./ValueType')
 
 class Enum extends ValueType {
   constructor (enumDef) {
-    var storageBytes = 0
-    var length = enumDef.children.length
+    let storageBytes = 0
+    let length = enumDef.children.length
     while (length > 1) {
       length = length / 256
       storageBytes++

remix-debug/src/solidity-decoder/types/FixedByteArray.js

 'use strict'
-var ValueType = require('./ValueType')
+const ValueType = require('./ValueType')
 
 class FixedByteArray extends ValueType {
   constructor (storageBytes) {

remix-debug/src/solidity-decoder/types/Int.js

 'use strict'
-var util = require('./util')
-var ValueType = require('./ValueType')
+const util = require('./util')
+const ValueType = require('./ValueType')
 
 class Int extends ValueType {
   constructor (storageBytes) {

remix-debug/src/solidity-decoder/types/Mapping.js

 'use strict'
-var RefType = require('./RefType')
-var util = require('./util')
-var ethutil = require('ethereumjs-util')
+const RefType = require('./RefType')
+const util = require('./util')
+const ethutil = require('ethereumjs-util')
 
 class Mapping extends RefType {
   constructor (underlyingTypes, location, fullType) {
@@ -12,9 +12,9 @@ class Mapping extends RefType {
   }
 
   async decodeFromStorage (location, storageResolver) {
-    var corrections = this.valueType.members ? this.valueType.members.map((value) => { return value.storagelocation }) : []
+    const corrections = this.valueType.members ? this.valueType.members.map((value) => { return value.storagelocation }) : []
     if (!this.initialDecodedState) { // cache the decoded initial storage
-      var mappingsInitialPreimages
+      let mappingsInitialPreimages
       try {
         mappingsInitialPreimages = await storageResolver.initialMappingsLocation(corrections)
         this.initialDecodedState = await this.decodeMappingsLocation(mappingsInitialPreimages, location, storageResolver)
@@ -25,8 +25,8 @@ class Mapping extends RefType {
         }
       }
     }
-    var mappingPreimages = await storageResolver.mappingsLocation(corrections)
-    var ret = await this.decodeMappingsLocation(mappingPreimages, location, storageResolver) // fetch mapping storage changes
+    const mappingPreimages = await storageResolver.mappingsLocation(corrections)
+    let ret = await this.decodeMappingsLocation(mappingPreimages, location, storageResolver) // fetch mapping storage changes
     ret = Object.assign({}, this.initialDecodedState, ret) // merge changes
     return {
       value: ret,
@@ -45,14 +45,14 @@ class Mapping extends RefType {
   }
 
   async decodeMappingsLocation (preimages, location, storageResolver) {
-    var mapSlot = util.normalizeHex(ethutil.bufferToHex(location.slot))
+    const mapSlot = util.normalizeHex(ethutil.bufferToHex(location.slot))
     if (!preimages[mapSlot]) {
       return {}
     }
-    var ret = {}
-    for (var i in preimages[mapSlot]) {
-      var mapLocation = getMappingLocation(i, location.slot)
-      var globalLocation = {
+    const ret = {}
+    for (let i in preimages[mapSlot]) {
+      const mapLocation = getMappingLocation(i, location.slot)
+      const globalLocation = {
         offset: location.offset,
         slot: mapLocation
       }
@@ -68,12 +68,12 @@ function getMappingLocation (key, position) {
   // > the value corresponding to a mapping key k is located at keccak256(k . p) where . is concatenation.
 
   // key should be a hex string, and position an int
-  var mappingK = ethutil.toBuffer('0x' + key)
-  var mappingP = ethutil.intToBuffer(position)
+  const mappingK = ethutil.toBuffer('0x' + key)
+  let mappingP = ethutil.intToBuffer(position)
   mappingP = ethutil.setLengthLeft(mappingP, 32)
-  var mappingKeyBuf = concatTypedArrays(mappingK, mappingP)
-  var mappingKeyPreimage = '0x' + mappingKeyBuf.toString('hex')
-  var mappingStorageLocation = ethutil.keccak(mappingKeyPreimage)
+  const mappingKeyBuf = concatTypedArrays(mappingK, mappingP)
+  const mappingKeyPreimage = '0x' + mappingKeyBuf.toString('hex')
+  let mappingStorageLocation = ethutil.keccak(mappingKeyPreimage)
   mappingStorageLocation = new ethutil.BN(mappingStorageLocation, 16)
   return mappingStorageLocation
 }

remix-debug/src/solidity-decoder/types/RefType.js

 'use strict'
-var util = require('./util')
+const util = require('./util')
 
 class RefType {
   constructor (storageSlots, storageBytes, typeName, location) {
@@ -26,7 +26,7 @@ class RefType {
         type: this.typeName
       }
     }
-    var offset = stack[stack.length - 1 - stackDepth]
+    let offset = stack[stack.length - 1 - stackDepth]
     if (this.isInStorage()) {
       offset = util.toBN(offset)
       try {

remix-debug/src/solidity-decoder/types/StringType.js

 'use strict'
-var DynamicBytes = require('./DynamicByteArray')
+const DynamicBytes = require('./DynamicByteArray')
 
 class StringType extends DynamicBytes {
   constructor (location) {
@@ -8,7 +8,7 @@ class StringType extends DynamicBytes {
   }
 
   async decodeFromStorage (location, storageResolver) {
-    var decoded = '0x'
+    let decoded = '0x'
     try {
       decoded = await super.decodeFromStorage(location, storageResolver)
     } catch (e) {
@@ -28,7 +28,7 @@ class StringType extends DynamicBytes {
   }
 
   decodeFromMemoryInternal (offset, memory) {
-    var decoded = super.decodeFromMemoryInternal(offset, memory)
+    const decoded = super.decodeFromMemoryInternal(offset, memory)
     return format(decoded)
   }
 }
@@ -37,9 +37,9 @@ function format (decoded) {
   if (decoded.error) {
     return decoded
   }
-  var value = decoded.value
+  let value = decoded.value
   value = value.replace('0x', '').replace(/(..)/g, '%$1')
-  var ret = {
+  const ret = {
     length: decoded.length,
     raw: decoded.value,
     type: 'string'

remix-debug/src/solidity-decoder/types/Struct.js

 'use strict'
-var util = require('./util')
-var RefType = require('./RefType')
+const util = require('./util')
+const RefType = require('./RefType')
 
 class Struct extends RefType {
   constructor (memberDetails, location, fullType) {
@@ -9,10 +9,10 @@ class Struct extends RefType {
   }
 
   async decodeFromStorage (location, storageResolver) {
-    var ret = {}
+    const ret = {}
     for (var k in this.members) {
-      var item = this.members[k]
-      var globalLocation = {
+      const item = this.members[k]
+      const globalLocation = {
         offset: location.offset + item.storagelocation.offset,
         slot: util.add(location.slot, item.storagelocation.slot)
       }
@@ -30,7 +30,7 @@ class Struct extends RefType {
   }
 
   decodeFromMemoryInternal (offset, memory) {
-    var ret = {}
+    const ret = {}
     this.members.map((item, i) => {
       var contentOffset = offset
       var member = item.type.decodeFromMemory(contentOffset, memory)

remix-debug/src/solidity-decoder/types/Uint.js

 'use strict'
-var util = require('./util')
-var ValueType = require('./ValueType')
+const util = require('./util')
+const ValueType = require('./ValueType')
 
 class Uint extends ValueType {
   constructor (storageBytes) {

remix-debug/src/solidity-decoder/types/ValueType.js

@@ -41,7 +41,7 @@ class ValueType {
     * @return {Object} - decoded value
     */
   async decodeFromStack (stackDepth, stack, memory) {
-    var value
+    let value
     if (stackDepth >= stack.length) {
       value = this.decodeValue('')
     } else {
@@ -61,7 +61,7 @@ class ValueType {
     * @return {Object} - decoded value
     */
   decodeFromMemory (offset, memory) {
-    var value = memory.substr(2 * offset, 64)
+    let value = memory.substr(2 * offset, 64)
     return {
       value: this.decodeValue(value),
       type: this.typeName

remix-debug/src/solidity-decoder/types/util.js

 'use strict'
-var ethutil = require('ethereumjs-util')
-var BN = require('ethereumjs-util').BN
+const ethutil = require('ethereumjs-util')
+const BN = require('ethereumjs-util').BN
 
 module.exports = {
   readFromStorage: readFromStorage,
@@ -17,7 +17,7 @@ module.exports = {
 }
 
 function decodeIntFromHex (value, byteLength, signed) {
-  var bigNumber = new BN(value, 16)
+  let bigNumber = new BN(value, 16)
   if (signed) {
     bigNumber = bigNumber.fromTwos(8 * byteLength)
   }
@@ -25,7 +25,7 @@ function decodeIntFromHex (value, byteLength, signed) {
 }
 
 function readFromStorage (slot, storageResolver) {
-  var hexSlot = '0x' + normalizeHex(ethutil.bufferToHex(slot))
+  const hexSlot = '0x' + normalizeHex(ethutil.bufferToHex(slot))
   return new Promise((resolve, reject) => {
     storageResolver.storageSlot(hexSlot, (error, slot) => {
       if (error) {
@@ -51,7 +51,7 @@ function readFromStorage (slot, storageResolver) {
  * @param {Int} offsetFromLSB  - byte distance from the right end slot value to the right end of the byte slice
  */
 function extractHexByteSlice (slotValue, byteLength, offsetFromLSB) {
-  var offset = slotValue.length - 2 * offsetFromLSB - 2 * byteLength
+  const offset = slotValue.length - 2 * offsetFromLSB - 2 * byteLength
   return slotValue.substr(offset, 2 * byteLength)
 }
 
@@ -63,7 +63,7 @@ function extractHexByteSlice (slotValue, byteLength, offsetFromLSB) {
  * @param {Int} byteLength  - Length of the byte slice to extract
  */
 async function extractHexValue (location, storageResolver, byteLength) {
-  var slotvalue
+  let slotvalue
   try {
     slotvalue = await readFromStorage(location.slot, storageResolver)
   } catch (e) {
@@ -97,7 +97,7 @@ function removeLocation (type) {
 }
 
 function extractLocation (type) {
-  var match = type.match(/( storage ref| storage pointer| memory| calldata)?$/)
+  let match = type.match(/( storage ref| storage pointer| memory| calldata)?$/)
   if (match[1] !== '') {
     return match[1].trim()
   } else {

remix-debug/src/storage/mappingPreimages.js

-var util = require('../solidity-decoder/types/util')
+const util = require('../solidity-decoder/types/util')
 
 module.exports = {
   decodeMappingsKeys: decodeMappingsKeys
@@ -14,14 +14,14 @@ module.exports = {
   * @return {Map} - solidity mapping location (e.g { "<mapping_slot>" : { "<mapping-key1>": preimageOf1 }, { "<mapping-key2>": preimageOf2 }, ... })
   */
 async function decodeMappingsKeys (web3, storage, corrections, callback) {
-  var ret = {}
+  const ret = {}
   if (!corrections.length) corrections.push({offset: 0, slot: 0})
-  for (var hashedLoc in storage) {
-    var preimage
+  for (let hashedLoc in storage) {
+    let preimage
     try {
-      var key = storage[hashedLoc].key
-      for (var k in corrections) {
-        var corrected = util.sub(key, corrections[k].slot).toString(16)
+      const key = storage[hashedLoc].key
+      for (let k in corrections) {
+        const corrected = util.sub(key, corrections[k].slot).toString(16)
         preimage = await getPreimage(web3, '0x' + corrected)
         if (preimage) break
       }
@@ -30,9 +30,9 @@ async function decodeMappingsKeys (web3, storage, corrections, callback) {
     if (preimage) {
       // got preimage!
       // get mapping position (i.e. storage slot), its the last 32 bytes
-      var slotByteOffset = preimage.length - 64
-      var mappingSlot = preimage.substr(slotByteOffset)
-      var mappingKey = preimage.substr(0, slotByteOffset)
+      const slotByteOffset = preimage.length - 64
+      const mappingSlot = preimage.substr(slotByteOffset)
+      const mappingKey = preimage.substr(0, slotByteOffset)
       if (!ret[mappingSlot]) {
         ret[mappingSlot] = {}
       }
@@ -50,7 +50,7 @@ async function decodeMappingsKeys (web3, storage, corrections, callback) {
   */
 function getPreimage (web3, key) {
   return new Promise((resolve, reject) => {
-    web3.debug.preimage(key.indexOf('0x') === 0 ? key : '0x' + key, function (error, preimage) {
+    web3.debug.preimage(key.indexOf('0x') === 0 ? key : '0x' + key, (error, preimage) => {
       if (error) {
         resolve(null)
       } else {

remix-debug/src/storage/storageResolver.js

 'use strict'
-var remixLib = require('remix-lib')
-var traceHelper = remixLib.helpers.trace
-var mappingPreimages = require('./mappingPreimages')
+const remixLib = require('remix-lib')
+const traceHelper = remixLib.helpers.trace
+const mappingPreimages = require('./mappingPreimages')
 
 /**
   * Basically one instance is created for one debugging session.
@@ -40,7 +40,6 @@ class StorageResolver {
    * @return {Function} - callback
    */
   initialPreimagesMappings (tx, stepIndex, address, corrections, callback) {
-    const self = this
     if (this.preimagesMappingByAddress[address]) {
       return callback(null, this.preimagesMappingByAddress[address])
     }
@@ -48,7 +47,7 @@ class StorageResolver {
       if (error) {
         return callback(error)
       }
-      mappingPreimages.decodeMappingsKeys(self.web3, storage, corrections, (error, mappings) => {
+      mappingPreimages.decodeMappingsKeys(this.web3, storage, corrections, (error, mappings) => {
         if (error) {
           callback(error)
         } else {
@@ -69,7 +68,7 @@ class StorageResolver {
    * @param {Function} - callback - {key, hashedKey, value} -
    */
   storageSlot (slot, tx, stepIndex, address, callback) {
-    this.storageRangeInternal(this, slot, tx, stepIndex, address, function (error, storage) {
+    this.storageRangeInternal(this, slot, tx, stepIndex, address, (error, storage) => {
       if (error) {
         callback(error)
       } else {

remix-debug/src/storage/storageViewer.js

 'use strict'
-var remixLib = require('remix-lib')
-var util = remixLib.util
-var mappingPreimages = require('./mappingPreimages')
+const remixLib = require('remix-lib')
+const util = remixLib.util
+const mappingPreimages = require('./mappingPreimages')
 
  /**
    * easier access to the storage resolver
@@ -46,7 +46,7 @@ class StorageViewer {
     * @param {Function} - callback - {key, hashedKey, value} -
     */
   storageSlot (slot, callback) {
-    var hashed = util.sha3_256(slot)
+    const hashed = util.sha3_256(slot)
     if (this.storageChanges[hashed]) {
       return callback(null, this.storageChanges[hashed])
     }