@optave/codegraph 3.1.0 → 3.1.2

package/src/ast-analysis/rules/csharp.js

@@ -0,0 +1,201 @@
+/**
+ * C# — AST analysis rules.
+ */
+
+import { makeCfgRules, makeDataflowRules } from '../shared.js';
+
+// ─── Complexity ───────────────────────────────────────────────────────────
+
+export const complexity = {
+  branchNodes: new Set([
+    'if_statement',
+    'else_clause',
+    'for_statement',
+    'foreach_statement',
+    'while_statement',
+    'do_statement',
+    'catch_clause',
+    'conditional_expression',
+    'switch_statement',
+  ]),
+  caseNodes: new Set(['switch_section']),
+  logicalOperators: new Set(['&&', '||', '??']),
+  logicalNodeType: 'binary_expression',
+  optionalChainType: 'conditional_access_expression',
+  nestingNodes: new Set([
+    'if_statement',
+    'for_statement',
+    'foreach_statement',
+    'while_statement',
+    'do_statement',
+    'catch_clause',
+    'conditional_expression',
+    'switch_statement',
+  ]),
+  functionNodes: new Set([
+    'method_declaration',
+    'constructor_declaration',
+    'lambda_expression',
+    'local_function_statement',
+  ]),
+  ifNodeType: 'if_statement',
+  elseNodeType: null,
+  elifNodeType: null,
+  elseViaAlternative: true,
+  switchLikeNodes: new Set(['switch_statement']),
+};
+
+// ─── Halstead ─────────────────────────────────────────────────────────────
+
+export const halstead = {
+  operatorLeafTypes: new Set([
+    '+',
+    '-',
+    '*',
+    '/',
+    '%',
+    '=',
+    '+=',
+    '-=',
+    '*=',
+    '/=',
+    '%=',
+    '&=',
+    '|=',
+    '^=',
+    '<<=',
+    '>>=',
+    '==',
+    '!=',
+    '<',
+    '>',
+    '<=',
+    '>=',
+    '&&',
+    '||',
+    '!',
+    '??',
+    '??=',
+    '&',
+    '|',
+    '^',
+    '~',
+    '<<',
+    '>>',
+    '++',
+    '--',
+    'is',
+    'as',
+    'new',
+    'typeof',
+    'sizeof',
+    'nameof',
+    'if',
+    'else',
+    'for',
+    'foreach',
+    'while',
+    'do',
+    'switch',
+    'case',
+    'return',
+    'throw',
+    'break',
+    'continue',
+    'try',
+    'catch',
+    'finally',
+    'await',
+    'yield',
+    '.',
+    '?.',
+    ',',
+    ';',
+    ':',
+    '=>',
+    '->',
+  ]),
+  operandLeafTypes: new Set([
+    'identifier',
+    'integer_literal',
+    'real_literal',
+    'string_literal',
+    'character_literal',
+    'verbatim_string_literal',
+    'interpolated_string_text',
+    'true',
+    'false',
+    'null',
+    'this',
+    'base',
+  ]),
+  compoundOperators: new Set([
+    'invocation_expression',
+    'element_access_expression',
+    'object_creation_expression',
+  ]),
+  skipTypes: new Set(['type_argument_list', 'type_parameter_list']),
+};
+
+// ─── CFG ──────────────────────────────────────────────────────────────────
+
+export const cfg = makeCfgRules({
+  ifNode: 'if_statement',
+  elseViaAlternative: true,
+  forNodes: new Set(['for_statement', 'foreach_statement']),
+  whileNode: 'while_statement',
+  doNode: 'do_statement',
+  switchNode: 'switch_statement',
+  caseNode: 'switch_section',
+  tryNode: 'try_statement',
+  catchNode: 'catch_clause',
+  finallyNode: 'finally_clause',
+  returnNode: 'return_statement',
+  throwNode: 'throw_statement',
+  breakNode: 'break_statement',
+  continueNode: 'continue_statement',
+  blockNode: 'block',
+  labeledNode: 'labeled_statement',
+  functionNodes: new Set([
+    'method_declaration',
+    'constructor_declaration',
+    'lambda_expression',
+    'local_function_statement',
+  ]),
+});
+
+// ─── Dataflow ─────────────────────────────────────────────────────────────
+
+export const dataflow = makeDataflowRules({
+  functionNodes: new Set([
+    'method_declaration',
+    'constructor_declaration',
+    'lambda_expression',
+    'local_function_statement',
+  ]),
+  returnNode: 'return_statement',
+  varDeclaratorNode: 'variable_declarator',
+  varNameField: 'name',
+  assignmentNode: 'assignment_expression',
+  callNode: 'invocation_expression',
+  callFunctionField: 'function',
+  callArgsField: 'arguments',
+  memberNode: 'member_access_expression',
+  memberObjectField: 'expression',
+  memberPropertyField: 'name',
+  awaitNode: 'await_expression',
+  argumentWrapperType: 'argument',
+  mutatingMethods: new Set(['Add', 'Remove', 'Clear', 'Insert', 'Sort', 'Reverse', 'Push', 'Pop']),
+  extractParamName(node) {
+    if (node.type === 'parameter') {
+      const nameNode = node.childForFieldName('name');
+      return nameNode ? [nameNode.text] : null;
+    }
+    if (node.type === 'identifier') return [node.text];
+    return null;
+  },
+});
+
+// ─── AST Node Types ───────────────────────────────────────────────────────
+
+export const astTypes = null;

package/src/ast-analysis/rules/go.js

@@ -0,0 +1,182 @@
+/**
+ * Go — AST analysis rules.
+ */
+
+import { makeCfgRules, makeDataflowRules } from '../shared.js';
+
+// ─── Complexity ───────────────────────────────────────────────────────────
+
+export const complexity = {
+  branchNodes: new Set([
+    'if_statement',
+    'for_statement',
+    'expression_switch_statement',
+    'type_switch_statement',
+    'select_statement',
+  ]),
+  caseNodes: new Set(['expression_case', 'type_case', 'default_case', 'communication_case']),
+  logicalOperators: new Set(['&&', '||']),
+  logicalNodeType: 'binary_expression',
+  optionalChainType: null,
+  nestingNodes: new Set([
+    'if_statement',
+    'for_statement',
+    'expression_switch_statement',
+    'type_switch_statement',
+    'select_statement',
+  ]),
+  functionNodes: new Set(['function_declaration', 'method_declaration', 'func_literal']),
+  ifNodeType: 'if_statement',
+  elseNodeType: null,
+  elifNodeType: null,
+  elseViaAlternative: true,
+  switchLikeNodes: new Set(['expression_switch_statement', 'type_switch_statement']),
+};
+
+// ─── Halstead ─────────────────────────────────────────────────────────────
+
+export const halstead = {
+  operatorLeafTypes: new Set([
+    '+',
+    '-',
+    '*',
+    '/',
+    '%',
+    '=',
+    ':=',
+    '+=',
+    '-=',
+    '*=',
+    '/=',
+    '%=',
+    '&=',
+    '|=',
+    '^=',
+    '<<=',
+    '>>=',
+    '==',
+    '!=',
+    '<',
+    '>',
+    '<=',
+    '>=',
+    '&&',
+    '||',
+    '!',
+    '&',
+    '|',
+    '^',
+    '~',
+    '<<',
+    '>>',
+    '&^',
+    '++',
+    '--',
+    'if',
+    'else',
+    'for',
+    'switch',
+    'select',
+    'case',
+    'default',
+    'return',
+    'break',
+    'continue',
+    'goto',
+    'fallthrough',
+    'go',
+    'defer',
+    'range',
+    'chan',
+    'func',
+    'var',
+    'const',
+    'type',
+    'struct',
+    'interface',
+    '.',
+    ',',
+    ';',
+    ':',
+    '<-',
+  ]),
+  operandLeafTypes: new Set([
+    'identifier',
+    'field_identifier',
+    'package_identifier',
+    'type_identifier',
+    'int_literal',
+    'float_literal',
+    'imaginary_literal',
+    'rune_literal',
+    'interpreted_string_literal',
+    'raw_string_literal',
+    'true',
+    'false',
+    'nil',
+    'iota',
+  ]),
+  compoundOperators: new Set(['call_expression', 'index_expression', 'selector_expression']),
+  skipTypes: new Set([]),
+};
+
+// ─── CFG ──────────────────────────────────────────────────────────────────
+
+export const cfg = makeCfgRules({
+  ifNode: 'if_statement',
+  elseViaAlternative: true,
+  forNodes: new Set(['for_statement']),
+  switchNodes: new Set([
+    'expression_switch_statement',
+    'type_switch_statement',
+    'select_statement',
+  ]),
+  caseNode: 'expression_case',
+  caseNodes: new Set(['type_case', 'communication_case']),
+  defaultNode: 'default_case',
+  returnNode: 'return_statement',
+  breakNode: 'break_statement',
+  continueNode: 'continue_statement',
+  blockNode: 'block',
+  labeledNode: 'labeled_statement',
+  functionNodes: new Set(['function_declaration', 'method_declaration', 'func_literal']),
+});
+
+// ─── Dataflow ─────────────────────────────────────────────────────────────
+
+export const dataflow = makeDataflowRules({
+  functionNodes: new Set(['function_declaration', 'method_declaration', 'func_literal']),
+  returnNode: 'return_statement',
+  varDeclaratorNodes: new Set(['short_var_declaration', 'var_declaration']),
+  varNameField: 'left',
+  varValueField: 'right',
+  assignmentNode: 'assignment_statement',
+  assignLeftField: 'left',
+  assignRightField: 'right',
+  callNode: 'call_expression',
+  callFunctionField: 'function',
+  callArgsField: 'arguments',
+  memberNode: 'selector_expression',
+  memberObjectField: 'operand',
+  memberPropertyField: 'field',
+  mutatingMethods: new Set(),
+  expressionListType: 'expression_list',
+  extractParamName(node) {
+    if (node.type === 'parameter_declaration') {
+      const names = [];
+      for (const c of node.namedChildren) {
+        if (c.type === 'identifier') names.push(c.text);
+      }
+      return names.length > 0 ? names : null;
+    }
+    if (node.type === 'variadic_parameter_declaration') {
+      const nameNode = node.childForFieldName('name');
+      return nameNode ? [nameNode.text] : null;
+    }
+    return null;
+  },
+});
+
+// ─── AST Node Types ───────────────────────────────────────────────────────
+
+export const astTypes = null;

package/src/ast-analysis/rules/index.js

@@ -0,0 +1,82 @@
+/**
+ * Assembled rule maps for all AST analysis modules.
+ *
+ * Re-exports per-language rules as Maps keyed by language ID.
+ */
+
+import * as csharp from './csharp.js';
+import * as go from './go.js';
+import * as java from './java.js';
+import * as javascript from './javascript.js';
+import * as php from './php.js';
+import * as python from './python.js';
+import * as ruby from './ruby.js';
+import * as rust from './rust.js';
+
+// ─── Complexity Rules ─────────────────────────────────────────────────────
+
+export const COMPLEXITY_RULES = new Map([
+  ['javascript', javascript.complexity],
+  ['typescript', javascript.complexity],
+  ['tsx', javascript.complexity],
+  ['python', python.complexity],
+  ['go', go.complexity],
+  ['rust', rust.complexity],
+  ['java', java.complexity],
+  ['csharp', csharp.complexity],
+  ['ruby', ruby.complexity],
+  ['php', php.complexity],
+]);
+
+// ─── Halstead Rules ───────────────────────────────────────────────────────
+
+export const HALSTEAD_RULES = new Map([
+  ['javascript', javascript.halstead],
+  ['typescript', javascript.halstead],
+  ['tsx', javascript.halstead],
+  ['python', python.halstead],
+  ['go', go.halstead],
+  ['rust', rust.halstead],
+  ['java', java.halstead],
+  ['csharp', csharp.halstead],
+  ['ruby', ruby.halstead],
+  ['php', php.halstead],
+]);
+
+// ─── CFG Rules ────────────────────────────────────────────────────────────
+
+export const CFG_RULES = new Map([
+  ['javascript', javascript.cfg],
+  ['typescript', javascript.cfg],
+  ['tsx', javascript.cfg],
+  ['python', python.cfg],
+  ['go', go.cfg],
+  ['rust', rust.cfg],
+  ['java', java.cfg],
+  ['csharp', csharp.cfg],
+  ['ruby', ruby.cfg],
+  ['php', php.cfg],
+]);
+
+// ─── Dataflow Rules ──────────────────────────────────────────────────────
+
+export const DATAFLOW_RULES = new Map([
+  ['javascript', javascript.dataflow],
+  ['typescript', javascript.dataflow],
+  ['tsx', javascript.dataflow],
+  ['python', python.dataflow],
+  ['go', go.dataflow],
+  ['rust', rust.dataflow],
+  ['java', java.dataflow],
+  ['csharp', csharp.dataflow],
+  ['php', php.dataflow],
+  ['ruby', ruby.dataflow],
+]);
+
+// ─── AST Type Maps ───────────────────────────────────────────────────────
+
+export const AST_TYPE_MAPS = new Map([
+  ['javascript', javascript.astTypes],
+  ['typescript', javascript.astTypes],
+  ['tsx', javascript.astTypes],
+]);

package/src/ast-analysis/rules/java.js

@@ -0,0 +1,175 @@
+/**
+ * Java — AST analysis rules.
+ */
+
+import { makeCfgRules, makeDataflowRules } from '../shared.js';
+
+// ─── Complexity ───────────────────────────────────────────────────────────
+
+export const complexity = {
+  branchNodes: new Set([
+    'if_statement',
+    'for_statement',
+    'enhanced_for_statement',
+    'while_statement',
+    'do_statement',
+    'catch_clause',
+    'ternary_expression',
+    'switch_expression',
+  ]),
+  caseNodes: new Set(['switch_label']),
+  logicalOperators: new Set(['&&', '||']),
+  logicalNodeType: 'binary_expression',
+  optionalChainType: null,
+  nestingNodes: new Set([
+    'if_statement',
+    'for_statement',
+    'enhanced_for_statement',
+    'while_statement',
+    'do_statement',
+    'catch_clause',
+    'ternary_expression',
+  ]),
+  functionNodes: new Set(['method_declaration', 'constructor_declaration', 'lambda_expression']),
+  ifNodeType: 'if_statement',
+  elseNodeType: null,
+  elifNodeType: null,
+  elseViaAlternative: true,
+  switchLikeNodes: new Set(['switch_expression']),
+};
+
+// ─── Halstead ─────────────────────────────────────────────────────────────
+
+export const halstead = {
+  operatorLeafTypes: new Set([
+    '+',
+    '-',
+    '*',
+    '/',
+    '%',
+    '=',
+    '+=',
+    '-=',
+    '*=',
+    '/=',
+    '%=',
+    '&=',
+    '|=',
+    '^=',
+    '<<=',
+    '>>=',
+    '>>>=',
+    '==',
+    '!=',
+    '<',
+    '>',
+    '<=',
+    '>=',
+    '&&',
+    '||',
+    '!',
+    '&',
+    '|',
+    '^',
+    '~',
+    '<<',
+    '>>',
+    '>>>',
+    '++',
+    '--',
+    'instanceof',
+    'new',
+    'if',
+    'else',
+    'for',
+    'while',
+    'do',
+    'switch',
+    'case',
+    'return',
+    'throw',
+    'break',
+    'continue',
+    'try',
+    'catch',
+    'finally',
+    '.',
+    ',',
+    ';',
+    ':',
+    '?',
+    '->',
+  ]),
+  operandLeafTypes: new Set([
+    'identifier',
+    'type_identifier',
+    'decimal_integer_literal',
+    'hex_integer_literal',
+    'octal_integer_literal',
+    'binary_integer_literal',
+    'decimal_floating_point_literal',
+    'hex_floating_point_literal',
+    'string_literal',
+    'character_literal',
+    'true',
+    'false',
+    'null',
+    'this',
+    'super',
+  ]),
+  compoundOperators: new Set(['method_invocation', 'array_access', 'object_creation_expression']),
+  skipTypes: new Set(['type_arguments', 'type_parameters']),
+};
+
+// ─── CFG ──────────────────────────────────────────────────────────────────
+
+export const cfg = makeCfgRules({
+  ifNode: 'if_statement',
+  elseViaAlternative: true,
+  forNodes: new Set(['for_statement', 'enhanced_for_statement']),
+  whileNode: 'while_statement',
+  doNode: 'do_statement',
+  switchNode: 'switch_expression',
+  caseNode: 'switch_block_statement_group',
+  caseNodes: new Set(['switch_rule']),
+  tryNode: 'try_statement',
+  catchNode: 'catch_clause',
+  finallyNode: 'finally_clause',
+  returnNode: 'return_statement',
+  throwNode: 'throw_statement',
+  breakNode: 'break_statement',
+  continueNode: 'continue_statement',
+  blockNode: 'block',
+  labeledNode: 'labeled_statement',
+  functionNodes: new Set(['method_declaration', 'constructor_declaration', 'lambda_expression']),
+});
+
+// ─── Dataflow ─────────────────────────────────────────────────────────────
+
+export const dataflow = makeDataflowRules({
+  functionNodes: new Set(['method_declaration', 'constructor_declaration', 'lambda_expression']),
+  returnNode: 'return_statement',
+  varDeclaratorNode: 'variable_declarator',
+  assignmentNode: 'assignment_expression',
+  callNodes: new Set(['method_invocation', 'object_creation_expression']),
+  callFunctionField: 'name',
+  callArgsField: 'arguments',
+  memberNode: 'field_access',
+  memberObjectField: 'object',
+  memberPropertyField: 'field',
+  callObjectField: 'object',
+  argumentWrapperType: 'argument',
+  mutatingMethods: new Set(['add', 'remove', 'clear', 'put', 'set', 'push', 'pop', 'sort']),
+  extractParamName(node) {
+    if (node.type === 'formal_parameter' || node.type === 'spread_parameter') {
+      const nameNode = node.childForFieldName('name');
+      return nameNode ? [nameNode.text] : null;
+    }
+    if (node.type === 'identifier') return [node.text];
+    return null;
+  },
+});
+
+// ─── AST Node Types ───────────────────────────────────────────────────────
+
+export const astTypes = null;