@codeque/core/dist/parserSettings/python/settings.js

Multiline code search for every language. Structural code search for JavaScript, TypeScript, HTML and CSS

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.pythonParser = exports.default = void 0;

var _traverseAndMatch = require("../../searchStages/traverseAndMatch");

var _common = require("./common");

var _parseCode = require("./parseCode");

const supportedExtensions = ['py'];

const getProgramNodeFromRootNode = rootNode => rootNode; // root node is program node


const getProgramBodyFromRootNode = fileNode => {
  return fileNode.children;
};

const unwrapExpressionStatement = node => {
  return node.nodeType === 'expression_statement' && node.children ? node.children[0] : node;
};

const createBlockStatementNode = (children, position) => ({
  nodeType: 'block',
  children,
  ...position
});

const isNode = maybeNode => {
  return typeof maybeNode?.nodeType === 'string';
};
/* start and end is added by CQ in multiline queries  */


const astPropsToSkip = ['loc', 'start', 'end'];
const nodeValuesSanitizers = {};

const getSanitizedNodeValue = (nodeType, valueKey, value) => {
  const valueSanitizer = nodeValuesSanitizers?.[nodeType]?.[valueKey];

  if (valueSanitizer) {
    return valueSanitizer(value);
  }

  return value;
};

const shouldCompareNode = node => {
  return true;
};

const isIdentifierNode = node => _common.identifierNodeTypes.includes((0, _common.getNodeType)(node));

const stringLikeLiteralUtils = {
  isStringLikeLiteralNode: node => node.nodeType === 'string_content',
  getStringLikeLiteralValue: node => {
    return node?.rawValue;
  }
};
const numericLiteralUtils = {
  isNumericLiteralNode: node => node.nodeType === 'integer' || node.nodeType === 'float',
  getNumericLiteralValue: node => node?.rawValue
};
const programNodeAndBlockNodeUtils = {
  isProgramNode: node => node.nodeType === 'module',
  isBlockNode: node => node.nodeType === 'block',
  programNodeBodyKey: 'children',
  blockNodeBodyKey: 'children'
};

const getNodePosition = node => ({
  start: node?.loc?.start?.index ?? 0,
  end: node?.loc?.end?.index ?? 0,
  loc: node.loc
});

const getParseErrorLocation = e => ({
  line: e.loc?.start?.line ?? 0,
  column: e.loc?.start?.column ?? 0
});

const alternativeNodeTypes = {
  identifier: _common.identifierNodeTypes
};
const encodedIdentifierWildcardSequence = 'a_x_2_x_a';
const encodedNodeWildcardSequence = 'a_x_3_x_a';

const preprocessQueryCode = code => {
  const queryCode = code.replace(/(\$\$\$)/g, () => encodedNodeWildcardSequence).replace(/(\$\$)/g, () => encodedIdentifierWildcardSequence);
  return queryCode;
};

const replaceEncodedWildcards = value => value.replace(/a_x_3_x_a/g, () => '$$$').replace(/a_x_2_x_a/g, () => '$$');

const postprocessQueryNode = queryNode => {
  (0, _traverseAndMatch.traverseAst)(queryNode, isNode, _common.getNodeType, {
    identifier: node => {
      const nodeName = node.rawValue;

      if (nodeName.includes(encodedNodeWildcardSequence) || nodeName.includes(encodedIdentifierWildcardSequence)) {
        node.rawValue = replaceEncodedWildcards(nodeName);
      }
    },
    string_content: node => {
      const nodeName = node.rawValue;

      if (nodeName.includes(encodedNodeWildcardSequence) || nodeName.includes(encodedIdentifierWildcardSequence)) {
        node.rawValue = replaceEncodedWildcards(nodeName);
      }
    }
  });
  return queryNode;
};

const pythonParser = {
  supportedExtensions,
  parseCode: _parseCode.parseCode,
  isNode,
  isIdentifierNode,
  astPropsToSkip,
  getProgramBodyFromRootNode,
  getProgramNodeFromRootNode,
  getIdentifierNodeName: _common.getIdentifierNodeName,
  getNodeType: _common.getNodeType,
  unwrapExpressionStatement,
  createBlockStatementNode,
  getSanitizedNodeValue,
  identifierNodeTypes: _common.identifierNodeTypes,
  setIdentifierNodeName: _common.setIdentifierNodeName,
  shouldCompareNode,
  wildcardUtils: _common.wildcardUtils,
  compareNodesBeforeWildcardsComparison: () => undefined,
  compareNodesAfterWildcardsComparison: () => undefined,
  identifierTypeAnnotationFieldName: '',
  stringLikeLiteralUtils,
  numericLiteralUtils,
  programNodeAndBlockNodeUtils,
  getNodePosition,
  getParseErrorLocation,
  alternativeNodeTypes,
  preprocessQueryCode,
  postprocessQueryNode,
  init: _parseCode.parserModule.init
};
exports.pythonParser = pythonParser;
var _default = pythonParser;
exports.default = _default;