babel-types.SourceLocation.start JavaScript and Node.js code examples

SwitchCase (node) {
   const line = node.loc.start.line
   const caseContent = node.test ? node.test.extra ? node.test.extra.raw : `${node.test.value}` : 'default'

   const mutantId = ++mutodeInstance.mutants
   const log = `MUTANT ${mutantId}:\tRSCM Lines ${node.loc.start.line}-${node.loc.end.line}: Commented case ${caseContent}`
   debug(log)
   mutodeInstance.mutantLog(log)
   const linesCopy = lines.slice()
   for (let i = line - 1; i < node.loc.end.line; i++) {
    linesCopy[i] = `// ${linesCopy[i]}`
   }
   const contentToWrite = linesCopy.join('\n')
   queue.push(mutantRunner({ mutodeInstance, filePath, contentToWrite, log }))
  }

UnaryExpression (node) {
   if (node.operator !== '-') {
    return
   }
   const line = node.loc.start.line
   const lineContent = lines[line - 1]

   const mutantLineContent = lineContent.substr(0, node.loc.start.column) +
    lineContent.substr(node.loc.start.column + 1)

   const mutantId = ++mutodeInstance.mutants
   const diff = lineDiff(lineContent, mutantLineContent)
   const log = `MUTANT ${mutantId}:\tINM Line ${line}:\t${diff}...`
   debug(log)
   mutodeInstance.mutantLog(`MUTANT ${mutantId}:\tINM ${filePath} Line ${line}:\t\`${lineContent.trim()}\` > \`${mutantLineContent.trim()}'\``)
   const linesCopy = lines.slice()
   linesCopy[line - 1] = mutantLineContent
   const contentToWrite = linesCopy.join('\n')
   queue.push(mutantRunner({ mutodeInstance, filePath, contentToWrite, log }))
  }

BinaryExpression (node) {
   for (const pair of operators) {
    if (node.operator !== pair[0] || node.left.loc.end - node.right.loc.start > 5) {
     continue
    }
    const line = node.loc.start.line
    const lineContent = lines[line - 1]

    const mutantLineContent = lineContent.substr(0, node.left.loc.end.column) +
     lineContent.substr(node.left.loc.end.column, node.right.loc.start.column - node.left.loc.end.column).replace(pair[0], pair[1]) +
     lineContent.substr(node.right.loc.start.column)

    const mutantId = ++mutodeInstance.mutants
    const diff = lineDiff(lineContent, mutantLineContent)
    const log = `MUTANT ${mutantId}:\tMM Line ${line}:\t${diff}`
    debug(log)
    mutodeInstance.mutantLog(`MUTANT ${mutantId}:\tMM ${filePath} Line ${line}:\t\`${lineContent.trim()}\` > \`${mutantLineContent.trim()}'\``)
    const linesCopy = lines.slice()
    linesCopy[line - 1] = mutantLineContent
    const contentToWrite = linesCopy.join('\n')
    queue.push(mutantRunner({ mutodeInstance, filePath, contentToWrite, log }))
   }
  }

NumericLiteral (node) {
   const line = node.loc.start.line
   const lineContent = lines[line - 1]

   const newValues = []

   if (node.value !== 0) newValues.push(0)
   if (node.value !== 1) newValues.push(node.value - 1)
   newValues.push(node.value + 1)
   newValues.push(Math.floor(Math.random() * 1000000))

   for (const newValue of newValues) {
    const mutantLineContent = lineContent.substr(0, node.loc.start.column) +
     newValue +
     lineContent.substr(node.loc.end.column)

    const mutantId = ++mutodeInstance.mutants
    const diff = lineDiff(lineContent, mutantLineContent)
    const log = `MUTANT ${mutantId}:\tNLM Line ${line}:\t${diff}...`
    debug(log)
    mutodeInstance.mutantLog(`MUTANT ${mutantId}:\tNLM ${filePath} Line ${line}:\t\`${lineContent.trim()}\` > \`${mutantLineContent.trim()}'\``)
    const linesCopy = lines.slice()
    linesCopy[line - 1] = mutantLineContent
    const contentToWrite = linesCopy.join('\n')
    queue.push(mutantRunner({ mutodeInstance, filePath, contentToWrite, log }))
   }
  }

UpdateExpression (node) {
   for (const pair of operators) {
    if (node.operator !== pair[0]) {
     continue
    }
    const line = node.loc.start.line
    const lineContent = lines[line - 1]

    const mutantLineContent = lineContent.substr(0, node.loc.start.column) +
     lineContent.substr(node.loc.start.column, node.loc.end.column - node.loc.start.column).replace(pair[0], pair[1]) +
     lineContent.substr(node.loc.end.column)

    const mutantId = ++mutodeInstance.mutants
    const diff = lineDiff(lineContent, mutantLineContent)
    const log = `MUTANT ${mutantId}:\tIM Line ${line}:\t${diff}...`
    debug(log)
    mutodeInstance.mutantLog(`MUTANT ${mutantId}:\tIM ${filePath} Line ${line}:\t\`${lineContent.trim()}\` > \`${mutantLineContent.trim()}'\``)
    const linesCopy = lines.slice()
    linesCopy[line - 1] = mutantLineContent
    const contentToWrite = linesCopy.join('\n')
    queue.push(mutantRunner({ mutodeInstance, filePath, contentToWrite, log }))
   }
  }

StringLiteral (node, state, ancestors) {
   const line = node.loc.start.line
   const lineContent = lines[line - 1]
    const mutantLineContent = lineContent.substr(0, node.loc.start.column) +
     node.extra.raw.replace(node.value, '') +
     lineContent.substr(node.loc.end.column)
   const mutantLineContent = lineContent.substr(0, node.loc.start.column) +
    newValue +
    lineContent.substr(node.loc.end.column)

if (node.loc.start.line !== node.loc.end.line) {
 const line = node.loc.start.line
 log = `MUTANT ${mutantId}:\tROPM Lines ${node.loc.start.line}-${node.loc.end.line}: Commented property ${propertyName}`
 debug(log)
 mutodeInstance.mutantLog(log)
 const line = node.loc.start.line
 const lineContent = lines[line - 1]
 let start = lineContent.substr(0, node.loc.start.column)
 if (start.trim().endsWith(',')) {
  start = start.substr(0, start.lastIndexOf(','))

BooleanLiteral (node) {
   const line = node.loc.start.line
   const lineContent = lines[line - 1]

   const mutantLineContent = lineContent.substr(0, node.loc.start.column) +
    !node.value +
    lineContent.substr(node.loc.end.column)

   const mutantId = ++mutodeInstance.mutants
   const diff = lineDiff(lineContent, mutantLineContent)
   const log = `MUTANT ${mutantId}:\tBLM Line ${line}:\t${diff}...`
   debug(log)
   mutodeInstance.mutantLog(`MUTANT ${mutantId}:\tBLM ${filePath} Line ${line}:\t\`${lineContent.trim()}\` > \`${mutantLineContent.trim()}'\``)
   const linesCopy = lines.slice()
   linesCopy[line - 1] = mutantLineContent
   const contentToWrite = linesCopy.join('\n')
   queue.push(mutantRunner({ mutodeInstance, filePath, contentToWrite, log }))
  }

BinaryExpression (node) {
   for (const operator of operators) {
    if (node.operator !== operator) {
     continue
    }
    const line = node.loc.start.line
    const lineContent = lines[line - 1]

    for (const replacement of ['true', 'false']) {
     const mutantLineContent = lineContent.substr(0, node.loc.start.column) +
      replacement +
      lineContent.substr(node.loc.end.column)

     const mutantId = ++mutodeInstance.mutants
     const diff = lineDiff(lineContent, mutantLineContent)
     const log = `MUTANT ${mutantId}:\tRCM Line ${line}:\t${diff}`
     debug(log)
     mutodeInstance.mutantLog(`MUTANT ${mutantId}:\tRCM ${filePath} Line ${line}:\t\`${lineContent.trim()}\` > \`${mutantLineContent.trim()}'\``)
     const linesCopy = lines.slice()
     linesCopy[line - 1] = mutantLineContent
     const contentToWrite = linesCopy.join('\n')
     queue.push(mutantRunner({ mutodeInstance, filePath, contentToWrite, log }))
    }
   }
  }

BinaryExpression (node) {
   for (const pair of operators) {
    if (node.operator !== pair[0]) {
     continue
    }
    const line = node.loc.start.line
    const lineContent = lines[line - 1]

    const mutantLineContent = lineContent.substr(0, node.loc.start.column) +
     lineContent.substr(node.loc.start.column, node.loc.end.column - node.loc.start.column).replace(pair[0], pair[1]) +
     lineContent.substr(node.loc.end.column)

    const mutantId = ++mutodeInstance.mutants
    const diff = lineDiff(lineContent, mutantLineContent)
    const log = `MUTANT ${mutantId}:\tCBM Line ${line}:\t${diff}`
    debug(log)
    mutodeInstance.mutantLog(`MUTANT ${mutantId}:\tCBM ${filePath} Line ${line}:\t\`${lineContent.trim()}\` > \`${mutantLineContent.trim()}'\``)
    const linesCopy = lines.slice()
    linesCopy[line - 1] = mutantLineContent
    const contentToWrite = linesCopy.join('\n')
    queue.push(mutantRunner({ mutodeInstance, filePath, contentToWrite, log }))
   }
  }

BinaryExpression (node) {
   for (const pair of operators) {
    if (node.operator !== pair[0]) {
     continue
    }
    const line = node.loc.start.line
    const lineContent = lines[line - 1]

    const mutantLineContent = lineContent.substr(0, node.loc.start.column) +
     lineContent.substr(node.loc.start.column, node.loc.end.column - node.loc.start.column).replace(pair[0], pair[1]) +
     lineContent.substr(node.loc.end.column)

    const mutantId = ++mutodeInstance.mutants
    const diff = lineDiff(lineContent, mutantLineContent)
    const log = `MUTANT ${mutantId}:\tNCM Line ${line}:\t${diff}`
    debug(log)
    mutodeInstance.mutantLog(`MUTANT ${mutantId}:\tNCM ${filePath} Line ${line}:\t\`${lineContent.trim()}\` > \`${mutantLineContent.trim()}'\``)
    const linesCopy = lines.slice()
    linesCopy[line - 1] = mutantLineContent
    const contentToWrite = linesCopy.join('\n')
    queue.push(mutantRunner({ mutodeInstance, filePath, contentToWrite, log }))
   }
  }

How to use startfunctionin SourceLocation

Best JavaScript code snippets using babel-types.SourceLocation.start(Showing top 11 results out of 315)

How to use
start
function
in
SourceLocation