driftdetect-core 0.1.2 → 0.3.0

package/dist/parsers/tree-sitter/tree-sitter-csharp-parser.js

@@ -0,0 +1,1146 @@
+/**
+ * Tree-sitter C# Parser
+ *
+ * C# parsing using tree-sitter-c-sharp with semantic extraction.
+ * Extracts usings, namespaces, classes, records, structs, interfaces,
+ * methods, properties, fields, and attributes.
+ *
+ * @requirements 3.2 - Support C# language
+ */
+import { BaseParser } from '../base-parser.js';
+import { isCSharpTreeSitterAvailable, createCSharpParser, getCSharpLoadingError } from './csharp-loader.js';
+import { CSharpASTConverter } from './csharp-ast-converter.js';
+// ============================================
+// Parser Implementation
+// ============================================
+/**
+ * Tree-sitter C# Parser
+ *
+ * Parses C# source code using tree-sitter-c-sharp and extracts
+ * semantic information including classes, records, methods, etc.
+ */
+export class TreeSitterCSharpParser extends BaseParser {
+    language = 'csharp';
+    extensions = ['.cs'];
+    parser = null;
+    converter;
+    currentNamespace = null;
+    constructor() {
+        super();
+        this.converter = new CSharpASTConverter();
+    }
+    /**
+     * Check if tree-sitter-c-sharp is available.
+     */
+    static isAvailable() {
+        return isCSharpTreeSitterAvailable();
+    }
+    /**
+     * Get the loading error if tree-sitter-c-sharp failed to load.
+     */
+    static getLoadingError() {
+        return getCSharpLoadingError();
+    }
+    /**
+     * Initialize the parser (lazy loading).
+     */
+    ensureParser() {
+        if (!this.parser) {
+            if (!isCSharpTreeSitterAvailable()) {
+                throw new Error(`C# parser not available: ${getCSharpLoadingError() ?? 'unknown error'}`);
+            }
+            this.parser = createCSharpParser();
+        }
+        return this.parser;
+    }
+    /**
+     * Parse C# source code.
+     */
+    parse(source, _filePath) {
+        try {
+            const parser = this.ensureParser();
+            const tree = parser.parse(source);
+            // Convert to drift AST
+            const rootNode = this.converter.convert(tree.rootNode);
+            const ast = {
+                rootNode,
+                text: source,
+            };
+            // Reset namespace tracking
+            this.currentNamespace = null;
+            // Extract semantic information
+            const usings = this.extractUsings(tree.rootNode);
+            const globalUsings = usings.filter(u => u.isGlobal);
+            const namespaces = this.extractNamespaces(tree.rootNode);
+            const classes = this.extractClasses(tree.rootNode);
+            const records = this.extractRecords(tree.rootNode);
+            const structs = this.extractStructs(tree.rootNode);
+            const interfaces = this.extractInterfaces(tree.rootNode);
+            const enums = this.extractEnums(tree.rootNode);
+            const topLevelStatements = this.hasTopLevelStatements(tree.rootNode);
+            return {
+                ast,
+                language: 'csharp',
+                errors: [],
+                success: true,
+                usings,
+                globalUsings,
+                namespaces,
+                classes,
+                records,
+                structs,
+                interfaces,
+                enums,
+                topLevelStatements,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown parse error';
+            return {
+                ast: null,
+                language: 'csharp',
+                errors: [{ message: errorMessage, position: { row: 0, column: 0 } }],
+                success: false,
+                usings: [],
+                globalUsings: [],
+                namespaces: [],
+                classes: [],
+                records: [],
+                structs: [],
+                interfaces: [],
+                enums: [],
+                topLevelStatements: false,
+            };
+        }
+    }
+    /**
+     * Query the AST for nodes matching a pattern.
+     */
+    query(ast, pattern) {
+        return this.findNodesByType(ast, pattern);
+    }
+    // ============================================
+    // Extraction Methods
+    // ============================================
+    extractUsings(root) {
+        const usings = [];
+        for (const child of root.children) {
+            if (child.type === 'using_directive') {
+                usings.push(this.parseUsingDirective(child));
+            }
+            else if (child.type === 'global_statement') {
+                // Check for global using
+                const usingChild = child.children.find(c => c.type === 'using_directive');
+                if (usingChild) {
+                    const using = this.parseUsingDirective(usingChild);
+                    using.isGlobal = true;
+                    usings.push(using);
+                }
+            }
+        }
+        return usings;
+    }
+    parseUsingDirective(node) {
+        let namespace = '';
+        let alias = null;
+        let isStatic = false;
+        let isGlobal = false;
+        for (const child of node.children) {
+            if (child.type === 'identifier' || child.type === 'qualified_name') {
+                namespace = child.text;
+            }
+            else if (child.type === 'name_equals') {
+                alias = child.children.find(c => c.type === 'identifier')?.text ?? null;
+            }
+            else if (child.text === 'static') {
+                isStatic = true;
+            }
+            else if (child.text === 'global') {
+                isGlobal = true;
+            }
+        }
+        return {
+            namespace,
+            alias,
+            isStatic,
+            isGlobal,
+            startPosition: { row: node.startPosition.row, column: node.startPosition.column },
+            endPosition: { row: node.endPosition.row, column: node.endPosition.column },
+        };
+    }
+    extractNamespaces(root) {
+        const namespaces = [];
+        for (const child of root.children) {
+            if (child.type === 'namespace_declaration') {
+                namespaces.push(this.parseNamespace(child, false));
+            }
+            else if (child.type === 'file_scoped_namespace_declaration') {
+                namespaces.push(this.parseNamespace(child, true));
+            }
+        }
+        return namespaces;
+    }
+    parseNamespace(node, isFileScoped) {
+        let name = '';
+        for (const child of node.children) {
+            if (child.type === 'identifier' || child.type === 'qualified_name') {
+                name = child.text;
+                this.currentNamespace = name;
+                break;
+            }
+        }
+        return {
+            name,
+            isFileScoped,
+            startPosition: { row: node.startPosition.row, column: node.startPosition.column },
+            endPosition: { row: node.endPosition.row, column: node.endPosition.column },
+        };
+    }
+    extractClasses(root) {
+        const classes = [];
+        this.findNodesOfType(root, 'class_declaration', (node) => {
+            classes.push(this.parseClass(node));
+        });
+        return classes;
+    }
+    parseClass(node) {
+        const info = {
+            name: '',
+            namespace: this.currentNamespace,
+            baseClass: null,
+            interfaces: [],
+            genericParameters: [],
+            attributes: [],
+            methods: [],
+            properties: [],
+            fields: [],
+            constructors: [],
+            nestedTypes: [],
+            accessibility: 'internal',
+            isStatic: false,
+            isAbstract: false,
+            isSealed: false,
+            isPartial: false,
+            startPosition: { row: node.startPosition.row, column: node.startPosition.column },
+            endPosition: { row: node.endPosition.row, column: node.endPosition.column },
+        };
+        for (const child of node.children) {
+            switch (child.type) {
+                case 'identifier':
+                    info.name = child.text;
+                    break;
+                case 'attribute_list':
+                    info.attributes.push(...this.parseAttributeList(child));
+                    break;
+                case 'modifier':
+                    this.applyModifier(info, child.text);
+                    break;
+                case 'type_parameter_list':
+                    info.genericParameters = this.parseTypeParameters(child);
+                    break;
+                case 'base_list':
+                    const bases = this.parseBaseList(child);
+                    if (bases.length > 0) {
+                        // First non-interface is base class
+                        const firstBase = bases[0];
+                        if (!firstBase.startsWith('I') || firstBase.length === 1 || !this.isUpperCase(firstBase[1])) {
+                            info.baseClass = firstBase;
+                            info.interfaces = bases.slice(1);
+                        }
+                        else {
+                            info.interfaces = bases;
+                        }
+                    }
+                    break;
+                case 'declaration_list':
+                    this.parseClassMembers(child, info);
+                    break;
+            }
+        }
+        return info;
+    }
+    parseClassMembers(node, classInfo) {
+        for (const child of node.children) {
+            switch (child.type) {
+                case 'method_declaration':
+                    classInfo.methods.push(this.parseMethod(child));
+                    break;
+                case 'property_declaration':
+                    classInfo.properties.push(this.parseProperty(child));
+                    break;
+                case 'field_declaration':
+                    classInfo.fields.push(...this.parseField(child));
+                    break;
+                case 'constructor_declaration':
+                    classInfo.constructors.push(this.parseConstructor(child));
+                    break;
+                case 'class_declaration':
+                case 'struct_declaration':
+                case 'interface_declaration':
+                case 'enum_declaration':
+                case 'record_declaration':
+                    const nestedName = child.children.find(c => c.type === 'identifier')?.text;
+                    if (nestedName) {
+                        classInfo.nestedTypes.push(nestedName);
+                    }
+                    break;
+            }
+        }
+    }
+    extractRecords(root) {
+        const records = [];
+        this.findNodesOfType(root, 'record_declaration', (node) => {
+            records.push(this.parseRecord(node));
+        });
+        return records;
+    }
+    parseRecord(node) {
+        const info = {
+            name: '',
+            namespace: this.currentNamespace,
+            isStruct: false,
+            primaryConstructorParams: [],
+            baseRecord: null,
+            interfaces: [],
+            genericParameters: [],
+            attributes: [],
+            methods: [],
+            properties: [],
+            accessibility: 'internal',
+            isSealed: false,
+            isAbstract: false,
+            isPartial: false,
+            startPosition: { row: node.startPosition.row, column: node.startPosition.column },
+            endPosition: { row: node.endPosition.row, column: node.endPosition.column },
+        };
+        for (const child of node.children) {
+            switch (child.type) {
+                case 'identifier':
+                    info.name = child.text;
+                    break;
+                case 'struct':
+                    info.isStruct = true;
+                    break;
+                case 'attribute_list':
+                    info.attributes.push(...this.parseAttributeList(child));
+                    break;
+                case 'modifier':
+                    this.applyRecordModifier(info, child.text);
+                    break;
+                case 'type_parameter_list':
+                    info.genericParameters = this.parseTypeParameters(child);
+                    break;
+                case 'parameter_list':
+                    info.primaryConstructorParams = this.parseParameters(child);
+                    break;
+                case 'base_list':
+                    const bases = this.parseBaseList(child);
+                    if (bases.length > 0) {
+                        info.baseRecord = bases[0] ?? null;
+                        info.interfaces = bases.slice(1);
+                    }
+                    break;
+                case 'declaration_list':
+                    this.parseRecordMembers(child, info);
+                    break;
+            }
+        }
+        return info;
+    }
+    parseRecordMembers(node, recordInfo) {
+        for (const child of node.children) {
+            switch (child.type) {
+                case 'method_declaration':
+                    recordInfo.methods.push(this.parseMethod(child));
+                    break;
+                case 'property_declaration':
+                    recordInfo.properties.push(this.parseProperty(child));
+                    break;
+            }
+        }
+    }
+    extractStructs(root) {
+        const structs = [];
+        this.findNodesOfType(root, 'struct_declaration', (node) => {
+            structs.push(this.parseStruct(node));
+        });
+        return structs;
+    }
+    parseStruct(node) {
+        const info = {
+            name: '',
+            namespace: this.currentNamespace,
+            interfaces: [],
+            genericParameters: [],
+            attributes: [],
+            methods: [],
+            properties: [],
+            fields: [],
+            constructors: [],
+            accessibility: 'internal',
+            isReadonly: false,
+            isRef: false,
+            isPartial: false,
+            startPosition: { row: node.startPosition.row, column: node.startPosition.column },
+            endPosition: { row: node.endPosition.row, column: node.endPosition.column },
+        };
+        for (const child of node.children) {
+            switch (child.type) {
+                case 'identifier':
+                    info.name = child.text;
+                    break;
+                case 'attribute_list':
+                    info.attributes.push(...this.parseAttributeList(child));
+                    break;
+                case 'modifier':
+                    this.applyStructModifier(info, child.text);
+                    break;
+                case 'type_parameter_list':
+                    info.genericParameters = this.parseTypeParameters(child);
+                    break;
+                case 'base_list':
+                    info.interfaces = this.parseBaseList(child);
+                    break;
+                case 'declaration_list':
+                    this.parseStructMembers(child, info);
+                    break;
+            }
+        }
+        return info;
+    }
+    parseStructMembers(node, structInfo) {
+        for (const child of node.children) {
+            switch (child.type) {
+                case 'method_declaration':
+                    structInfo.methods.push(this.parseMethod(child));
+                    break;
+                case 'property_declaration':
+                    structInfo.properties.push(this.parseProperty(child));
+                    break;
+                case 'field_declaration':
+                    structInfo.fields.push(...this.parseField(child));
+                    break;
+                case 'constructor_declaration':
+                    structInfo.constructors.push(this.parseConstructor(child));
+                    break;
+            }
+        }
+    }
+    extractInterfaces(root) {
+        const interfaces = [];
+        this.findNodesOfType(root, 'interface_declaration', (node) => {
+            interfaces.push(this.parseInterface(node));
+        });
+        return interfaces;
+    }
+    parseInterface(node) {
+        const info = {
+            name: '',
+            namespace: this.currentNamespace,
+            extends: [],
+            genericParameters: [],
+            attributes: [],
+            methods: [],
+            properties: [],
+            accessibility: 'internal',
+            isPartial: false,
+            startPosition: { row: node.startPosition.row, column: node.startPosition.column },
+            endPosition: { row: node.endPosition.row, column: node.endPosition.column },
+        };
+        for (const child of node.children) {
+            switch (child.type) {
+                case 'identifier':
+                    info.name = child.text;
+                    break;
+                case 'attribute_list':
+                    info.attributes.push(...this.parseAttributeList(child));
+                    break;
+                case 'modifier':
+                    this.applyInterfaceModifier(info, child.text);
+                    break;
+                case 'type_parameter_list':
+                    info.genericParameters = this.parseTypeParameters(child);
+                    break;
+                case 'base_list':
+                    info.extends = this.parseBaseList(child);
+                    break;
+                case 'declaration_list':
+                    this.parseInterfaceMembers(child, info);
+                    break;
+            }
+        }
+        return info;
+    }
+    parseInterfaceMembers(node, interfaceInfo) {
+        for (const child of node.children) {
+            switch (child.type) {
+                case 'method_declaration':
+                    interfaceInfo.methods.push(this.parseMethod(child));
+                    break;
+                case 'property_declaration':
+                    interfaceInfo.properties.push(this.parseProperty(child));
+                    break;
+            }
+        }
+    }
+    extractEnums(root) {
+        const enums = [];
+        this.findNodesOfType(root, 'enum_declaration', (node) => {
+            enums.push(this.parseEnum(node));
+        });
+        return enums;
+    }
+    parseEnum(node) {
+        const info = {
+            name: '',
+            namespace: this.currentNamespace,
+            underlyingType: null,
+            members: [],
+            attributes: [],
+            accessibility: 'internal',
+            startPosition: { row: node.startPosition.row, column: node.startPosition.column },
+            endPosition: { row: node.endPosition.row, column: node.endPosition.column },
+        };
+        for (const child of node.children) {
+            switch (child.type) {
+                case 'identifier':
+                    info.name = child.text;
+                    break;
+                case 'attribute_list':
+                    info.attributes.push(...this.parseAttributeList(child));
+                    break;
+                case 'modifier':
+                    if (child.text === 'public')
+                        info.accessibility = 'public';
+                    else if (child.text === 'internal')
+                        info.accessibility = 'internal';
+                    else if (child.text === 'private')
+                        info.accessibility = 'private';
+                    break;
+                case 'base_list':
+                    const bases = this.parseBaseList(child);
+                    if (bases.length > 0) {
+                        info.underlyingType = bases[0] ?? null;
+                    }
+                    break;
+                case 'enum_member_declaration_list':
+                    info.members = this.parseEnumMembers(child);
+                    break;
+            }
+        }
+        return info;
+    }
+    parseEnumMembers(node) {
+        const members = [];
+        for (const child of node.children) {
+            if (child.type === 'enum_member_declaration') {
+                let name = '';
+                let value = null;
+                for (const memberChild of child.children) {
+                    if (memberChild.type === 'identifier') {
+                        name = memberChild.text;
+                    }
+                    else if (memberChild.type === 'equals_value_clause') {
+                        value = memberChild.children.find(c => c.type !== '=')?.text ?? null;
+                    }
+                }
+                if (name) {
+                    members.push({ name, value });
+                }
+            }
+        }
+        return members;
+    }
+    hasTopLevelStatements(root) {
+        for (const child of root.children) {
+            if (child.type === 'global_statement') {
+                // Check if it's not just a using directive
+                const hasNonUsing = child.children.some(c => c.type !== 'using_directive');
+                if (hasNonUsing) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    // ============================================
+    // Helper Methods
+    // ============================================
+    parseAttributeList(node) {
+        const attributes = [];
+        for (const child of node.children) {
+            if (child.type === 'attribute') {
+                attributes.push(this.parseAttribute(child));
+            }
+        }
+        return attributes;
+    }
+    parseAttribute(node) {
+        const info = {
+            name: '',
+            fullName: '',
+            arguments: [],
+            namedArguments: {},
+            target: null,
+            startPosition: { row: node.startPosition.row, column: node.startPosition.column },
+            endPosition: { row: node.endPosition.row, column: node.endPosition.column },
+        };
+        for (const child of node.children) {
+            if (child.type === 'identifier' || child.type === 'qualified_name') {
+                info.fullName = child.text;
+                // Remove 'Attribute' suffix if present
+                info.name = info.fullName.replace(/Attribute$/, '');
+            }
+            else if (child.type === 'attribute_argument_list') {
+                this.parseAttributeArguments(child, info);
+            }
+        }
+        return info;
+    }
+    parseAttributeArguments(node, info) {
+        for (const child of node.children) {
+            if (child.type === 'attribute_argument') {
+                const nameEquals = child.children.find(c => c.type === 'name_equals');
+                if (nameEquals) {
+                    const name = nameEquals.children.find(c => c.type === 'identifier')?.text;
+                    const value = child.children.find(c => c.type !== 'name_equals')?.text;
+                    if (name && value) {
+                        info.namedArguments[name] = value;
+                    }
+                }
+                else {
+                    const value = child.text;
+                    if (value) {
+                        info.arguments.push(value);
+                    }
+                }
+            }
+        }
+    }
+    parseMethod(node) {
+        const info = {
+            name: '',
+            returnType: 'void',
+            parameters: [],
+            genericParameters: [],
+            attributes: [],
+            accessibility: 'private',
+            isStatic: false,
+            isAsync: false,
+            isVirtual: false,
+            isOverride: false,
+            isAbstract: false,
+            isSealed: false,
+            isExtern: false,
+            isPartial: false,
+            startPosition: { row: node.startPosition.row, column: node.startPosition.column },
+            endPosition: { row: node.endPosition.row, column: node.endPosition.column },
+        };
+        for (const child of node.children) {
+            switch (child.type) {
+                case 'identifier':
+                    info.name = child.text;
+                    break;
+                case 'attribute_list':
+                    info.attributes.push(...this.parseAttributeList(child));
+                    break;
+                case 'modifier':
+                    this.applyMethodModifier(info, child.text);
+                    break;
+                case 'type_parameter_list':
+                    info.genericParameters = this.parseTypeParameters(child);
+                    break;
+                case 'parameter_list':
+                    info.parameters = this.parseParameters(child);
+                    break;
+                case 'predefined_type':
+                case 'identifier':
+                case 'qualified_name':
+                case 'generic_name':
+                case 'nullable_type':
+                case 'array_type':
+                case 'tuple_type':
+                    // Return type - take the first type we find before the method name
+                    if (!info.name) {
+                        info.returnType = child.text;
+                    }
+                    break;
+            }
+        }
+        // Handle return type more carefully
+        const returnTypeNode = node.childForFieldName?.('type') ??
+            node.children.find(c => ['predefined_type', 'generic_name', 'qualified_name', 'nullable_type', 'array_type', 'tuple_type'].includes(c.type));
+        if (returnTypeNode) {
+            info.returnType = returnTypeNode.text;
+        }
+        return info;
+    }
+    parseProperty(node) {
+        const info = {
+            name: '',
+            type: '',
+            hasGetter: false,
+            hasSetter: false,
+            isInit: false,
+            isRequired: false,
+            attributes: [],
+            accessibility: 'private',
+            isStatic: false,
+            isVirtual: false,
+            isOverride: false,
+            isAbstract: false,
+            startPosition: { row: node.startPosition.row, column: node.startPosition.column },
+            endPosition: { row: node.endPosition.row, column: node.endPosition.column },
+        };
+        for (const child of node.children) {
+            switch (child.type) {
+                case 'identifier':
+                    info.name = child.text;
+                    break;
+                case 'attribute_list':
+                    info.attributes.push(...this.parseAttributeList(child));
+                    break;
+                case 'modifier':
+                    this.applyPropertyModifier(info, child.text);
+                    break;
+                case 'predefined_type':
+                case 'generic_name':
+                case 'qualified_name':
+                case 'nullable_type':
+                case 'array_type':
+                case 'tuple_type':
+                    info.type = child.text;
+                    break;
+                case 'accessor_list':
+                    this.parseAccessors(child, info);
+                    break;
+            }
+        }
+        return info;
+    }
+    parseAccessors(node, propertyInfo) {
+        for (const child of node.children) {
+            if (child.type === 'accessor_declaration') {
+                const accessorType = child.children.find(c => c.type === 'identifier' || c.text === 'get' || c.text === 'set' || c.text === 'init');
+                if (accessorType) {
+                    if (accessorType.text === 'get') {
+                        propertyInfo.hasGetter = true;
+                    }
+                    else if (accessorType.text === 'set') {
+                        propertyInfo.hasSetter = true;
+                    }
+                    else if (accessorType.text === 'init') {
+                        propertyInfo.hasSetter = true;
+                        propertyInfo.isInit = true;
+                    }
+                }
+            }
+        }
+    }
+    parseField(node) {
+        const fields = [];
+        const baseInfo = {
+            type: '',
+            defaultValue: null,
+            attributes: [],
+            accessibility: 'private',
+            isStatic: false,
+            isReadonly: false,
+            isConst: false,
+            isVolatile: false,
+        };
+        for (const child of node.children) {
+            switch (child.type) {
+                case 'attribute_list':
+                    baseInfo.attributes = [...(baseInfo.attributes ?? []), ...this.parseAttributeList(child)];
+                    break;
+                case 'modifier':
+                    this.applyFieldModifier(baseInfo, child.text);
+                    break;
+                case 'predefined_type':
+                case 'generic_name':
+                case 'qualified_name':
+                case 'nullable_type':
+                case 'array_type':
+                case 'tuple_type':
+                    baseInfo.type = child.text;
+                    break;
+                case 'variable_declaration':
+                    for (const varChild of child.children) {
+                        if (varChild.type === 'variable_declarator') {
+                            const fieldInfo = {
+                                name: '',
+                                type: baseInfo.type ?? '',
+                                defaultValue: null,
+                                attributes: baseInfo.attributes ?? [],
+                                accessibility: baseInfo.accessibility ?? 'private',
+                                isStatic: baseInfo.isStatic ?? false,
+                                isReadonly: baseInfo.isReadonly ?? false,
+                                isConst: baseInfo.isConst ?? false,
+                                isVolatile: baseInfo.isVolatile ?? false,
+                                startPosition: { row: node.startPosition.row, column: node.startPosition.column },
+                                endPosition: { row: node.endPosition.row, column: node.endPosition.column },
+                            };
+                            for (const declChild of varChild.children) {
+                                if (declChild.type === 'identifier') {
+                                    fieldInfo.name = declChild.text;
+                                }
+                                else if (declChild.type === 'equals_value_clause') {
+                                    fieldInfo.defaultValue = declChild.children.find(c => c.type !== '=')?.text ?? null;
+                                }
+                            }
+                            if (fieldInfo.name) {
+                                fields.push(fieldInfo);
+                            }
+                        }
+                    }
+                    break;
+            }
+        }
+        return fields;
+    }
+    parseConstructor(node) {
+        const info = {
+            parameters: [],
+            attributes: [],
+            accessibility: 'private',
+            isStatic: false,
+            initializer: null,
+            startPosition: { row: node.startPosition.row, column: node.startPosition.column },
+            endPosition: { row: node.endPosition.row, column: node.endPosition.column },
+        };
+        for (const child of node.children) {
+            switch (child.type) {
+                case 'attribute_list':
+                    info.attributes.push(...this.parseAttributeList(child));
+                    break;
+                case 'modifier':
+                    if (child.text === 'public')
+                        info.accessibility = 'public';
+                    else if (child.text === 'private')
+                        info.accessibility = 'private';
+                    else if (child.text === 'protected')
+                        info.accessibility = 'protected';
+                    else if (child.text === 'internal')
+                        info.accessibility = 'internal';
+                    else if (child.text === 'static')
+                        info.isStatic = true;
+                    break;
+                case 'parameter_list':
+                    info.parameters = this.parseParameters(child);
+                    break;
+                case 'constructor_initializer':
+                    const initType = child.children.find(c => c.text === 'base' || c.text === 'this');
+                    if (initType) {
+                        info.initializer = {
+                            type: initType.text,
+                            arguments: [],
+                        };
+                        const argList = child.children.find(c => c.type === 'argument_list');
+                        if (argList) {
+                            info.initializer.arguments = argList.children
+                                .filter(c => c.type === 'argument')
+                                .map(c => c.text);
+                        }
+                    }
+                    break;
+            }
+        }
+        return info;
+    }
+    parseParameters(node) {
+        const params = [];
+        for (const child of node.children) {
+            if (child.type === 'parameter') {
+                params.push(this.parseParameter(child));
+            }
+        }
+        return params;
+    }
+    parseParameter(node) {
+        const info = {
+            name: '',
+            type: '',
+            defaultValue: null,
+            isRef: false,
+            isOut: false,
+            isIn: false,
+            isParams: false,
+            isThis: false,
+            attributes: [],
+        };
+        for (const child of node.children) {
+            switch (child.type) {
+                case 'identifier':
+                    info.name = child.text;
+                    break;
+                case 'attribute_list':
+                    info.attributes.push(...this.parseAttributeList(child));
+                    break;
+                case 'parameter_modifier':
+                case 'modifier':
+                    if (child.text === 'ref')
+                        info.isRef = true;
+                    else if (child.text === 'out')
+                        info.isOut = true;
+                    else if (child.text === 'in')
+                        info.isIn = true;
+                    else if (child.text === 'params')
+                        info.isParams = true;
+                    else if (child.text === 'this')
+                        info.isThis = true;
+                    break;
+                case 'predefined_type':
+                case 'generic_name':
+                case 'qualified_name':
+                case 'nullable_type':
+                case 'array_type':
+                case 'tuple_type':
+                    info.type = child.text;
+                    break;
+                case 'equals_value_clause':
+                    info.defaultValue = child.children.find(c => c.type !== '=')?.text ?? null;
+                    break;
+            }
+        }
+        return info;
+    }
+    parseTypeParameters(node) {
+        const params = [];
+        for (const child of node.children) {
+            if (child.type === 'type_parameter') {
+                const name = child.children.find(c => c.type === 'identifier')?.text;
+                if (name) {
+                    params.push(name);
+                }
+            }
+        }
+        return params;
+    }
+    parseBaseList(node) {
+        const bases = [];
+        for (const child of node.children) {
+            if (child.type === 'simple_base_type' || child.type === 'primary_constructor_base_type') {
+                const typeName = child.children.find(c => c.type === 'identifier' || c.type === 'generic_name' || c.type === 'qualified_name')?.text;
+                if (typeName) {
+                    bases.push(typeName);
+                }
+            }
+        }
+        return bases;
+    }
+    // ============================================
+    // Modifier Application
+    // ============================================
+    applyModifier(info, modifier) {
+        switch (modifier) {
+            case 'public':
+                info.accessibility = 'public';
+                break;
+            case 'private':
+                info.accessibility = 'private';
+                break;
+            case 'protected':
+                info.accessibility = 'protected';
+                break;
+            case 'internal':
+                info.accessibility = 'internal';
+                break;
+            case 'static':
+                info.isStatic = true;
+                break;
+            case 'abstract':
+                info.isAbstract = true;
+                break;
+            case 'sealed':
+                info.isSealed = true;
+                break;
+            case 'partial':
+                info.isPartial = true;
+                break;
+        }
+    }
+    applyRecordModifier(info, modifier) {
+        switch (modifier) {
+            case 'public':
+                info.accessibility = 'public';
+                break;
+            case 'private':
+                info.accessibility = 'private';
+                break;
+            case 'protected':
+                info.accessibility = 'protected';
+                break;
+            case 'internal':
+                info.accessibility = 'internal';
+                break;
+            case 'sealed':
+                info.isSealed = true;
+                break;
+            case 'abstract':
+                info.isAbstract = true;
+                break;
+            case 'partial':
+                info.isPartial = true;
+                break;
+        }
+    }
+    applyStructModifier(info, modifier) {
+        switch (modifier) {
+            case 'public':
+                info.accessibility = 'public';
+                break;
+            case 'private':
+                info.accessibility = 'private';
+                break;
+            case 'protected':
+                info.accessibility = 'protected';
+                break;
+            case 'internal':
+                info.accessibility = 'internal';
+                break;
+            case 'readonly':
+                info.isReadonly = true;
+                break;
+            case 'ref':
+                info.isRef = true;
+                break;
+            case 'partial':
+                info.isPartial = true;
+                break;
+        }
+    }
+    applyInterfaceModifier(info, modifier) {
+        switch (modifier) {
+            case 'public':
+                info.accessibility = 'public';
+                break;
+            case 'private':
+                info.accessibility = 'private';
+                break;
+            case 'protected':
+                info.accessibility = 'protected';
+                break;
+            case 'internal':
+                info.accessibility = 'internal';
+                break;
+            case 'partial':
+                info.isPartial = true;
+                break;
+        }
+    }
+    applyMethodModifier(info, modifier) {
+        switch (modifier) {
+            case 'public':
+                info.accessibility = 'public';
+                break;
+            case 'private':
+                info.accessibility = 'private';
+                break;
+            case 'protected':
+                info.accessibility = 'protected';
+                break;
+            case 'internal':
+                info.accessibility = 'internal';
+                break;
+            case 'static':
+                info.isStatic = true;
+                break;
+            case 'async':
+                info.isAsync = true;
+                break;
+            case 'virtual':
+                info.isVirtual = true;
+                break;
+            case 'override':
+                info.isOverride = true;
+                break;
+            case 'abstract':
+                info.isAbstract = true;
+                break;
+            case 'sealed':
+                info.isSealed = true;
+                break;
+            case 'extern':
+                info.isExtern = true;
+                break;
+            case 'partial':
+                info.isPartial = true;
+                break;
+        }
+    }
+    applyPropertyModifier(info, modifier) {
+        switch (modifier) {
+            case 'public':
+                info.accessibility = 'public';
+                break;
+            case 'private':
+                info.accessibility = 'private';
+                break;
+            case 'protected':
+                info.accessibility = 'protected';
+                break;
+            case 'internal':
+                info.accessibility = 'internal';
+                break;
+            case 'static':
+                info.isStatic = true;
+                break;
+            case 'virtual':
+                info.isVirtual = true;
+                break;
+            case 'override':
+                info.isOverride = true;
+                break;
+            case 'abstract':
+                info.isAbstract = true;
+                break;
+            case 'required':
+                info.isRequired = true;
+                break;
+        }
+    }
+    applyFieldModifier(info, modifier) {
+        switch (modifier) {
+            case 'public':
+                info.accessibility = 'public';
+                break;
+            case 'private':
+                info.accessibility = 'private';
+                break;
+            case 'protected':
+                info.accessibility = 'protected';
+                break;
+            case 'internal':
+                info.accessibility = 'internal';
+                break;
+            case 'static':
+                info.isStatic = true;
+                break;
+            case 'readonly':
+                info.isReadonly = true;
+                break;
+            case 'const':
+                info.isConst = true;
+                break;
+            case 'volatile':
+                info.isVolatile = true;
+                break;
+        }
+    }
+    // ============================================
+    // Utility Methods
+    // ============================================
+    findNodesOfType(node, type, callback) {
+        if (node.type === type) {
+            callback(node);
+        }
+        for (const child of node.children) {
+            this.findNodesOfType(child, type, callback);
+        }
+    }
+    isUpperCase(char) {
+        return char === char.toUpperCase() && char !== char.toLowerCase();
+    }
+}
+//# sourceMappingURL=tree-sitter-csharp-parser.js.map