index.js

function isFallbackFunction(node) {
  return isFunctionDefinition(node) && node.isFallback
}

function isReceiveFunction(node) {
  return isFunctionDefinition(node) && node.isReceiveEther
}

function isFunctionDefinition(node) {
  return node.type === 'FunctionDefinition'
}

class CustomOrderingChecker {
  constructor(reporter, config) {
    this.ruleId = 'custom-ordering'
    this.reporter = reporter

    this.functionsOrder = config
      && config.rules[`custom-functions-order/${this.ruleId}`]
      && config.rules[`custom-functions-order/${this.ruleId}`][1]
      && config.rules[`custom-functions-order/${this.ruleId}`][1].functionsOrder
  }

  SourceUnit(node) {
    const children = node.children

    this.checkOrder(children, sourceUnitPartOrder)
  }

  ContractDefinition(node) {
    const children = node.subNodes

    this.checkOrder(children, contractPartOrder)
  }

  checkOrder(children, orderFunction) {
    if (children.length === 0) {
      return
    }

    let maxChild = children[0]
    let [maxComparisonValue, maxLabel] = orderFunction(children[0], this.functionsOrder)

    for (let i = 1; i < children.length; i++) {
      const [comparisonValue, label] = orderFunction(children[i], this.functionsOrder)
      if (comparisonValue < maxComparisonValue) {
        this.report(children[i], maxChild, label, maxLabel)
        return
      }

      maxChild = children[i]
      maxComparisonValue = comparisonValue
      maxLabel = label
    }
  }

  report(node, nodeBefore, label, labelBefore) {
    const message = `Function order is incorrect, ${label} can not go after ${labelBefore} (line ${
      nodeBefore.loc.start.line
    })`
    this.reporter.error(node, this.ruleId, message)
  }
}

function getMutabilityWeight({ baseWeight, stateMutability }) {
  switch (stateMutability) {
    case 'constant':
    case 'view':
      return baseWeight + 2
    case 'pure':
      return baseWeight + 4
    default:
      return baseWeight
  }
}

function isTypeDeclaration(node) {
  return ['StructDefinition', 'EnumDefinition'].includes(node.type)
}

function sourceUnitPartOrder(node) {
  if (node.type === 'PragmaDirective') {
    return [0, 'pragma directive']
  }

  if (node.type === 'ImportDirective') {
    return [10, 'import directive']
  }

  if (node.type === 'EnumDefinition' || node.type === 'StructDefinition') {
    return [20, 'type definition']
  }

  if (node.type === 'ContractDefinition') {
    if (node.kind === 'interface') {
      return [30, 'interface']
    }

    if (node.kind === 'library') {
      return [40, 'library definition']
    }

    if (node.kind === 'contract') {
      return [50, 'contract definition']
    }
  }

  throw new Error('Unrecognized source unit part, please report this issue')
}

function contractPartOrder(node, functionsOrder) {
  if (node.type === 'UsingForDeclaration') {
    return [0, 'using for declaration']
  }

  if (isTypeDeclaration(node)) {
    let label
    if (node.type === 'StructDefinition') {
      label = 'struct definition'
    } else {
      label = 'enum definition'
    }

    return [10, label]
  }

  if (node.type === 'StateVariableDeclaration') {
    return [20, 'state variable declaration']
  }

  if (node.type === 'EventDefinition') {
    return [30, 'event definition']
  }

  if (node.type === 'ModifierDefinition') {
    return [40, 'modifier definition']
  }

  if (node.isConstructor) {
    return [50, 'constructor']
  }

  if (isReceiveFunction(node)) {
    return [60, 'receive function']
  }

  if (isFallbackFunction(node)) {
    return [70, 'fallback function']
  }

  if (node.type === 'FunctionDefinition') {
    const { stateMutability, visibility } = node

    if (!functionsOrder || functionsOrder.length === 0) {
      return defaultOrdering(node)
    }

    const vs = stateMutability ? [visibility, stateMutability].join(' ') : visibility
    const index = functionsOrder.findIndex(e => e === vs)

    const label = [vs, 'function'].join(' ')
    const weight = 70 + ((index + 1) * 10)

    return [weight, label]
  }

  throw new Error('Unrecognized contract part, please report this issue')
}

function defaultOrdering(node) {
  const { stateMutability, visibility } = node

  if (visibility === 'external') {
    const weight = getMutabilityWeight({ baseWeight: 80, stateMutability })
    const label = [visibility, stateMutability, 'function'].join(' ')

    return [weight, label]
  }

  if (visibility === 'public') {
    const weight = getMutabilityWeight({ baseWeight: 90, stateMutability })
    const label = [visibility, stateMutability, 'function'].join(' ')

    return [weight, label]
  }

  if (visibility === 'internal') {
    const weight = getMutabilityWeight({ baseWeight: 100, stateMutability })
    const label = [visibility, stateMutability, 'function'].join(' ')
    return [weight, label]
  }

  if (visibility === 'private') {
    const weight = getMutabilityWeight({ baseWeight: 110, stateMutability })
    const label = [visibility, stateMutability, 'function'].join(' ')
    return [weight, label]
  }

  throw new Error('Unknown order for function, please report this issue')
}

module.exports = [CustomOrderingChecker]