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 }))
   }
  }

Most used babel-types functions

Popular in JavaScript

qs
A querystring parser that supports nesting and arrays, with a depth limit
yargs
yargs the modern, pirate-themed, successor to optimist.
lodash
Lodash modular utilities.
express
Fast, unopinionated, minimalist web framework
async
Higher-order functions and common patterns for asynchronous code
commander
the complete solution for node.js command-line programs
js-yaml
YAML 1.2 parser and serializer
q
A library for promises (CommonJS/Promises/A,B,D)
semver
The semantic version parser used by npm.
Top plugins for WebStorm
The challenge is finding the best plugins for JavaScript development on Intellij IDEs. Who wants to sit there and go over hundreds of plugins to pick the best?

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