gitnexus 1.6.12-rc.2 → 1.6.12-rc.21

package/dist/core/ingestion/languages/objective-c/facts.js

@@ -0,0 +1,1150 @@
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { generateId } from '../../../../lib/utils.js';
+import { nodeToCapture, walkNamedTree } from '../../utils/ast-helpers.js';
+export const OBJECTIVE_C_PROVIDER_VERSION = '0.1.8';
+export const OBJECTIVE_C_GRAMMAR_PACKAGE = 'tree-sitter-objc';
+export const OBJECTIVE_C_GRAMMAR_VERSION = '3.0.2';
+const factsByFile = new Map();
+export function setObjectiveCFileFacts(facts) {
+    factsByFile.set(facts.filePath, facts);
+}
+export function getObjectiveCFileFacts(filePath) {
+    return factsByFile.get(filePath);
+}
+/** Drop process-local facts before a new workspace pass (Java/Kotlin analog). */
+export function clearObjectiveCFileFacts() {
+    factsByFile.clear();
+}
+export function collectObjectiveCCaptureSideChannel(filePath) {
+    const facts = factsByFile.get(filePath);
+    return facts === undefined ? undefined : { kind: 'objective-c', facts };
+}
+export function applyObjectiveCCaptureSideChannel(parsed) {
+    const payload = parsed.captureSideChannel;
+    if (!isObjectiveCSideChannel(payload))
+        return;
+    factsByFile.set(payload.facts.filePath, payload.facts);
+}
+export function objectiveCFactsFromParsedFiles(parsedFiles) {
+    const facts = [];
+    const seen = new Set();
+    for (const parsed of parsedFiles) {
+        const payload = parsed.captureSideChannel;
+        const fromPayload = isObjectiveCSideChannel(payload) ? payload.facts : undefined;
+        const fact = fromPayload ?? factsByFile.get(parsed.filePath);
+        if (fact === undefined || seen.has(fact.filePath))
+            continue;
+        seen.add(fact.filePath);
+        facts.push(fact);
+    }
+    return facts;
+}
+function isObjectiveCSideChannel(value) {
+    if (value === null || typeof value !== 'object')
+        return false;
+    const record = value;
+    return record.kind === 'objective-c' && record.facts !== null && typeof record.facts === 'object';
+}
+export const objcClassQualifiedName = (name) => `objc:class:${name}`;
+export const objcProtocolQualifiedName = (name) => `objc:protocol:${name}`;
+export const objcCategoryQualifiedName = (hostClass, categoryName) => `objc:category:${hostClass}:${categoryName}`;
+export const objcMethodQualifiedName = (ownerQualifiedName, methodKind, selector) => `objc:method:${ownerQualifiedName}:${methodKind}:${selector}`;
+export const objcPropertyQualifiedName = (ownerQualifiedName, name) => `objc:property:${ownerQualifiedName}:${name}`;
+export const objcIvarQualifiedName = (ownerQualifiedName, name) => `objc:ivar:${ownerQualifiedName}:${name}`;
+export const objcFunctionQualifiedName = (name, linkage = 'external', filePath) => linkage === 'internal' && filePath !== undefined
+    ? `objc:function:static:${filePath}:${name}`
+    : `objc:function:${name}`;
+/** True for C functions this provider models as translation-unit local. */
+export function isInternalObjectiveCFunctionDef(def) {
+    const qualifiedName = def.qualifiedName ?? '';
+    const nodeId = def.nodeId ?? '';
+    return (qualifiedName.startsWith('objc:function:static:') || nodeId.includes('objc:function:static:'));
+}
+export const objcUnresolvedMessageQualifiedName = (filePath, startLine, startCol, selector) => `objc:unresolved:${filePath}:${startLine}:${startCol}:${selector}`;
+const graphNodeId = (label, qualifiedName) => generateId(label, qualifiedName);
+function ownerLabel(kind) {
+    return kind === 'class' ? 'Class' : kind === 'protocol' ? 'Protocol' : 'Category';
+}
+const range = (node) => ({
+    startLine: node.startPosition.row,
+    endLine: node.endPosition.row,
+});
+function directNamedChildren(node) {
+    const out = [];
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child !== null)
+            out.push(child);
+    }
+    return out;
+}
+function directChildren(node) {
+    const out = [];
+    for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child !== null)
+            out.push(child);
+    }
+    return out;
+}
+function directIdentifiers(node) {
+    return directNamedChildren(node).filter((child) => child.type === 'identifier');
+}
+function logicalTopLevelNodes(root) {
+    const nodes = [];
+    const visit = (node) => {
+        for (const child of directNamedChildren(node)) {
+            if (child.type === 'preproc_if' ||
+                child.type === 'preproc_ifdef' ||
+                child.type === 'preproc_else' ||
+                child.type === 'preproc_elif') {
+                visit(child);
+            }
+            else {
+                nodes.push(child);
+            }
+        }
+    };
+    visit(root);
+    return nodes;
+}
+function containerMemberNodes(containerNode) {
+    const members = [];
+    const visit = (node) => {
+        for (const child of directNamedChildren(node)) {
+            if (child.type === 'qualified_protocol_interface_declaration') {
+                visit(child);
+            }
+            else {
+                members.push(child);
+            }
+        }
+    };
+    visit(containerNode);
+    return members;
+}
+function stripQuotes(raw) {
+    const trimmed = raw.trim();
+    if ((trimmed.startsWith('"') && trimmed.endsWith('"')) ||
+        (trimmed.startsWith('<') && trimmed.endsWith('>'))) {
+        return trimmed.slice(1, -1);
+    }
+    return trimmed;
+}
+function isSystemHeaderSpelling(raw) {
+    const trimmed = raw.trim();
+    return trimmed.startsWith('<') && trimmed.endsWith('>');
+}
+function cleanType(raw) {
+    if (raw === undefined)
+        return undefined;
+    const text = raw
+        .replace(/^\(/, '')
+        .replace(/\)$/, '')
+        .replace(/\b(?:nullable|nonnull|__nullable|__nonnull|_Nullable|_Nonnull|const)\b/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+    if (text.length === 0)
+        return undefined;
+    return text;
+}
+export function parseObjCType(raw) {
+    const text = cleanType(raw);
+    if (text === undefined)
+        return undefined;
+    if (text === 'id' || text === 'instancetype')
+        return { kind: 'dynamic', raw: text };
+    if (text === 'Class')
+        return { kind: 'class-object', raw: text };
+    const protocolMatch = text.match(/^id\s*<\s*([A-Za-z_][A-Za-z0-9_]*)\s*>/);
+    if (protocolMatch !== null) {
+        return { kind: 'protocol', name: protocolMatch[1], raw: text };
+    }
+    const classMatch = text.match(/([A-Za-z_][A-Za-z0-9_]*)\s*(?:<[^>]+>)?\s*\*?$/);
+    if (classMatch !== null) {
+        return { kind: 'class', name: classMatch[1], raw: text };
+    }
+    return { kind: 'unknown', raw: text };
+}
+function methodKind(node) {
+    const first = node.child(0)?.text;
+    return first === '+' ? '+' : '-';
+}
+function methodTypeText(node) {
+    const typeNode = directNamedChildren(node).find((child) => child.type === 'method_type');
+    return cleanType(typeNode?.text);
+}
+function methodSelector(node) {
+    const children = directChildren(node);
+    const keywordDeclarators = children.filter((child) => child.type === 'keyword_declarator');
+    if (keywordDeclarators.length > 0) {
+        return keywordDeclarators
+            .map((declarator) => directIdentifiers(declarator)[0]?.text)
+            .filter((name) => name !== undefined)
+            .map((name) => `${name}:`)
+            .join('');
+    }
+    const pieces = [];
+    for (let i = 0; i < children.length; i++) {
+        const child = children[i];
+        if (child.type !== 'identifier')
+            continue;
+        const next = children[i + 1];
+        if (next?.type === 'method_parameter') {
+            pieces.push(`${child.text}:`);
+            continue;
+        }
+        if (pieces.length === 0)
+            pieces.push(child.text);
+    }
+    return pieces.join('');
+}
+function messageSelector(node) {
+    const children = directChildren(node);
+    const pieces = [];
+    for (let i = 2; i < children.length; i++) {
+        const child = children[i];
+        if (child.type !== 'identifier' && child.type !== 'field_identifier')
+            continue;
+        const next = children[i + 1];
+        if (next?.text === ':')
+            pieces.push(`${child.text}:`);
+        else if (pieces.length === 0 && next?.text === ']')
+            pieces.push(child.text);
+    }
+    return pieces.join('');
+}
+function methodParameterInfo(node) {
+    const parameterTypes = [];
+    const parameterNames = [];
+    const typeBindings = new Map();
+    for (const child of directNamedChildren(node)) {
+        if (child.type !== 'method_parameter' && child.type !== 'keyword_declarator')
+            continue;
+        const named = directNamedChildren(child);
+        const typeNode = named.find((n) => n.type === 'method_type');
+        const nameNode = [...named].reverse().find((n) => n.type === 'identifier');
+        const typeText = cleanType(typeNode?.text);
+        if (typeText !== undefined)
+            parameterTypes.push(typeText);
+        if (nameNode !== undefined) {
+            parameterNames.push(nameNode.text);
+            const parsed = parseObjCType(typeText);
+            if (parsed !== undefined)
+                typeBindings.set(nameNode.text, parsed);
+        }
+    }
+    return { parameterTypes, parameterNames, typeBindings };
+}
+function propertyInfos(node) {
+    const structDecl = directNamedChildren(node).find((child) => child.type === 'struct_declaration');
+    if (structDecl === undefined)
+        return [];
+    return declarationNamesAndType(structDecl);
+}
+function declarationNameAndType(node) {
+    return declarationNamesAndType(node)[0] ?? null;
+}
+function declarationNamesAndType(node) {
+    const type = cleanType(firstTypeNode(node)?.text);
+    return declaratorNames(node).map((name) => (type !== undefined ? { name, type } : { name }));
+}
+function declaratorNames(node) {
+    const names = [];
+    collectDeclaratorNames(node, names);
+    return names;
+}
+function collectDeclaratorNames(node, out) {
+    if (node.type === 'identifier') {
+        out.push(node.text);
+        return;
+    }
+    if (node.type === 'init_declarator' ||
+        node.type === 'pointer_declarator' ||
+        node.type === 'array_declarator' ||
+        node.type === 'function_declarator' ||
+        node.type === 'parenthesized_declarator' ||
+        node.type === 'struct_declarator') {
+        for (const child of directNamedChildren(node))
+            collectDeclaratorNames(child, out);
+        return;
+    }
+    for (const child of directNamedChildren(node)) {
+        if (child.type === 'identifier' ||
+            child.type === 'init_declarator' ||
+            child.type === 'pointer_declarator' ||
+            child.type === 'array_declarator' ||
+            child.type === 'function_declarator' ||
+            child.type === 'parenthesized_declarator' ||
+            child.type === 'struct_declarator' ||
+            child.type === 'struct_declaration') {
+            collectDeclaratorNames(child, out);
+        }
+    }
+}
+function declaratorName(node) {
+    if (node.type === 'identifier')
+        return node.text;
+    if (node.type === 'init_declarator') {
+        for (const child of directNamedChildren(node)) {
+            const name = declaratorName(child);
+            if (name !== undefined)
+                return name;
+        }
+        return undefined;
+    }
+    if (node.type === 'pointer_declarator' ||
+        node.type === 'array_declarator' ||
+        node.type === 'function_declarator' ||
+        node.type === 'parenthesized_declarator' ||
+        node.type === 'struct_declarator') {
+        for (const child of directNamedChildren(node)) {
+            const name = declaratorName(child);
+            if (name !== undefined)
+                return name;
+        }
+        return undefined;
+    }
+    for (const child of directNamedChildren(node)) {
+        if (child.type === 'identifier' ||
+            child.type === 'init_declarator' ||
+            child.type === 'pointer_declarator' ||
+            child.type === 'array_declarator' ||
+            child.type === 'function_declarator' ||
+            child.type === 'parenthesized_declarator' ||
+            child.type === 'struct_declarator' ||
+            child.type === 'struct_declaration') {
+            const name = declaratorName(child);
+            if (name !== undefined)
+                return name;
+        }
+    }
+    return undefined;
+}
+function firstTypeNode(node) {
+    if (node.type === 'type_identifier' ||
+        node.type === 'primitive_type' ||
+        node.type === 'typedefed_specifier') {
+        return node;
+    }
+    for (const child of directNamedChildren(node)) {
+        const found = firstTypeNode(child);
+        if (found !== undefined)
+            return found;
+    }
+    return undefined;
+}
+function functionInfos(node) {
+    const declarators = [];
+    const collect = (current) => {
+        for (const child of directNamedChildren(current)) {
+            if (child.type === 'function_declarator') {
+                declarators.push(child);
+                continue;
+            }
+            collect(child);
+        }
+    };
+    collect(node);
+    const returnType = cleanType(directNamedChildren(node).find((child) => child.type === 'type_identifier' ||
+        child.type === 'primitive_type' ||
+        child.type === 'typedefed_specifier')?.text);
+    const linkage = directNamedChildren(node).some((child) => child.type === 'storage_class_specifier' && child.text === 'static')
+        ? 'internal'
+        : 'external';
+    return declarators.flatMap((declarator) => {
+        // `int (*callback)(int)` is a function pointer declaration, not a callable
+        // definition. A pointer return (`int *func(void)`) remains a C function.
+        if (declarator.childForFieldName('declarator')?.type === 'parenthesized_declarator') {
+            return [];
+        }
+        const name = declaratorName(declarator);
+        if (name === undefined)
+            return [];
+        const parameterTypes = [];
+        walkNamedTree(declarator, (child) => {
+            if (child.type !== 'parameter_declaration')
+                return;
+            const typeNode = directNamedChildren(child).find((n) => n.type === 'type_identifier' ||
+                n.type === 'primitive_type' ||
+                n.type === 'typedefed_specifier');
+            const typeText = cleanType(typeNode?.text);
+            if (typeText !== undefined)
+                parameterTypes.push(typeText);
+        });
+        return [{ name, linkage, returnType, parameterTypes }];
+    });
+}
+function directProtocolNames(node) {
+    const out = [];
+    for (const child of directNamedChildren(node)) {
+        if (child.type === 'protocol_reference_list') {
+            out.push(...directIdentifiers(child).map((id) => id.text));
+        }
+        else if (child.type === 'parameterized_arguments') {
+            for (const named of directNamedChildren(child)) {
+                if (named.type !== 'type_name')
+                    continue;
+                const id = directNamedChildren(named).find((n) => n.type === 'type_identifier');
+                if (id !== undefined)
+                    out.push(id.text);
+            }
+        }
+    }
+    return Array.from(new Set(out));
+}
+function parseContainer(node, filePath) {
+    if (node.type !== 'class_interface' &&
+        node.type !== 'class_implementation' &&
+        node.type !== 'protocol_declaration') {
+        return null;
+    }
+    const ids = directIdentifiers(node);
+    const first = ids[0];
+    if (first === undefined)
+        return null;
+    const { startLine, endLine } = range(node);
+    if (node.type === 'protocol_declaration') {
+        const qualifiedName = objcProtocolQualifiedName(first.text);
+        return {
+            kind: 'protocol',
+            declarationRole: 'interface',
+            name: first.text,
+            qualifiedName,
+            nodeId: graphNodeId('Protocol', qualifiedName),
+            label: 'Protocol',
+            filePath,
+            startLine,
+            endLine,
+            protocols: directProtocolNames(node).filter((name) => name !== first.text),
+        };
+    }
+    const children = directChildren(node);
+    const openParenIndex = children.findIndex((child) => child.text === '(');
+    if (openParenIndex !== -1) {
+        const categoryIdentifier = children
+            .slice(openParenIndex + 1)
+            .find((child) => child.type === 'identifier');
+        const categoryName = categoryIdentifier?.text ?? '__extension__';
+        const kind = categoryIdentifier === undefined ? 'extension' : 'category';
+        const qualifiedName = objcCategoryQualifiedName(first.text, categoryName);
+        return {
+            kind,
+            declarationRole: node.type === 'class_interface' ? 'interface' : 'implementation',
+            name: `${first.text} (${categoryIdentifier?.text ?? ''})`,
+            qualifiedName,
+            nodeId: graphNodeId('Category', qualifiedName),
+            label: 'Category',
+            filePath,
+            startLine,
+            endLine,
+            protocols: directProtocolNames(node),
+            hostClass: first.text,
+            categoryName,
+        };
+    }
+    const colonIndex = children.findIndex((child) => child.text === ':');
+    const superclass = colonIndex !== -1
+        ? children.slice(colonIndex + 1).find((child) => child.type === 'identifier')?.text
+        : undefined;
+    const qualifiedName = objcClassQualifiedName(first.text);
+    return {
+        kind: 'class',
+        declarationRole: node.type === 'class_interface' ? 'interface' : 'implementation',
+        name: first.text,
+        qualifiedName,
+        nodeId: graphNodeId('Class', qualifiedName),
+        label: 'Class',
+        filePath,
+        startLine,
+        endLine,
+        ...(superclass !== undefined ? { superclass } : {}),
+        protocols: directProtocolNames(node),
+    };
+}
+function enclosingCompoundScope(node, methodBody) {
+    let current = node.parent;
+    while (current !== null && current !== methodBody) {
+        if (current.type === 'compound_statement')
+            return current;
+        current = current.parent;
+    }
+    return methodBody;
+}
+function collectMethodBindings(methodNode, parameterTypes) {
+    const methodBody = directNamedChildren(methodNode).find((child) => child.type === 'compound_statement');
+    if (methodBody === undefined)
+        return [];
+    const bindings = [...parameterTypes].map(([name, type]) => ({
+        name,
+        type,
+        declarationIndex: methodBody.startIndex,
+        scopeStartIndex: methodBody.startIndex,
+        scopeEndIndex: methodBody.endIndex,
+    }));
+    walkNamedTree(methodBody, (node) => {
+        if (node.type !== 'declaration')
+            return;
+        const info = declarationNameAndType(node);
+        if (info === null)
+            return;
+        const type = parseObjCType(info.type);
+        if (type === undefined)
+            return;
+        const scope = enclosingCompoundScope(node, methodBody);
+        bindings.push({
+            name: info.name,
+            type,
+            declarationIndex: node.endIndex,
+            scopeStartIndex: scope.startIndex,
+            scopeEndIndex: scope.endIndex,
+        });
+    });
+    return bindings;
+}
+function bindingAt(bindings, name, sourceIndex) {
+    const matches = bindings.filter((binding) => binding.name === name &&
+        binding.declarationIndex <= sourceIndex &&
+        binding.scopeStartIndex <= sourceIndex &&
+        sourceIndex <= binding.scopeEndIndex);
+    matches.sort((left, right) => {
+        const leftScope = left.scopeEndIndex - left.scopeStartIndex;
+        const rightScope = right.scopeEndIndex - right.scopeStartIndex;
+        return leftScope - rightScope || right.declarationIndex - left.declarationIndex;
+    });
+    return matches[0]?.type;
+}
+function isReflectionSelector(selector, receiverText) {
+    return (selector.startsWith('performSelector:') ||
+        selector === 'methodForSelector:' ||
+        selector === 'forwardInvocation:' ||
+        receiverText === 'NSInvocation');
+}
+function isPascalCaseLike(text) {
+    if (!/^[A-Z][A-Za-z0-9]*$/.test(text))
+        return false;
+    return text.length === 1 || /[a-z0-9]/.test(text.slice(1));
+}
+function messageReceiver(node) {
+    return directNamedChildren(node)[0] ?? null;
+}
+function macroName(node) {
+    return node.childForFieldName('name')?.text ?? directIdentifiers(node)[0]?.text;
+}
+function classifyReceiver(receiver, selector, method, methodBindings, membersByOwner, macroNames, classNames) {
+    const text = receiver.text;
+    if (isReflectionSelector(selector, text)) {
+        return {
+            kind: 'dynamic',
+            unresolvedReason: 'reflection selector dispatch is dynamic',
+        };
+    }
+    const receiverMacroName = receiver.type === 'call_expression'
+        ? receiver.childForFieldName('function')?.text
+        : receiver.type === 'identifier'
+            ? text
+            : undefined;
+    if (receiverMacroName !== undefined && macroNames.has(receiverMacroName)) {
+        return {
+            kind: 'dynamic',
+            type: { kind: 'dynamic', raw: text },
+            unresolvedReason: `macro receiver ${receiverMacroName} is dynamic`,
+        };
+    }
+    if (receiver.type === 'identifier') {
+        if (text === 'self')
+            return { kind: 'self' };
+        if (text === 'super')
+            return { kind: 'super' };
+        const bound = bindingAt(methodBindings, text, receiver.startIndex);
+        if (bound !== undefined) {
+            if (bound.kind === 'dynamic' || bound.kind === 'class-object') {
+                return {
+                    kind: 'dynamic',
+                    type: bound,
+                    unresolvedReason: `${bound.raw} receiver is dynamic`,
+                };
+            }
+            return { kind: 'local', type: bound };
+        }
+        const hostOwner = method.hostClass !== undefined
+            ? objcClassQualifiedName(method.hostClass)
+            : method.ownerQualifiedName;
+        const memberType = membersByOwner.get(hostOwner)?.get(text);
+        if (memberType !== undefined)
+            return { kind: 'ivar', type: memberType };
+        if (classNames.has(text) || isPascalCaseLike(text)) {
+            return { kind: 'class', type: { kind: 'class', name: text, raw: text } };
+        }
+        return { kind: 'unknown', memberName: text };
+    }
+    if (receiver.type === 'field_expression') {
+        const parts = directNamedChildren(receiver);
+        const base = parts[0];
+        const field = parts[1];
+        if (base?.text === 'self' && field !== undefined) {
+            const hostOwner = method.hostClass !== undefined
+                ? objcClassQualifiedName(method.hostClass)
+                : method.ownerQualifiedName;
+            const memberType = membersByOwner.get(hostOwner)?.get(field.text);
+            if (memberType !== undefined)
+                return { kind: 'property', type: memberType };
+            return { kind: 'property', memberName: field.text };
+        }
+    }
+    return {
+        kind: 'unknown',
+        unresolvedReason: 'receiver expression is not statically typed',
+    };
+}
+function collectMethodMessages(methodNode, method, parameterTypes, membersByOwner, macroNames, classNames, messages, unresolvedMessages) {
+    const methodBindings = collectMethodBindings(methodNode, parameterTypes);
+    walkNamedTree(methodNode, (messageNode) => {
+        if (messageNode.type !== 'message_expression')
+            return;
+        const receiver = messageReceiver(messageNode);
+        if (receiver === null)
+            return;
+        const selector = messageSelector(messageNode);
+        if (selector.length === 0)
+            return;
+        const classified = classifyReceiver(receiver, selector, method, methodBindings, membersByOwner, macroNames, classNames);
+        const fact = {
+            selector,
+            receiverText: receiver.text,
+            receiverKind: classified.kind,
+            ...(classified.type !== undefined ? { receiverType: classified.type } : {}),
+            ...(classified.memberName !== undefined ? { receiverMemberName: classified.memberName } : {}),
+            sourceMethodQualifiedName: method.qualifiedName,
+            sourceMethodId: method.nodeId,
+            sourceOwnerQualifiedName: method.ownerQualifiedName,
+            sourceOwnerName: method.ownerName,
+            sourceMethodKind: method.methodKind,
+            filePath: method.filePath,
+            startLine: messageNode.startPosition.row,
+            startCol: messageNode.startPosition.column,
+        };
+        if (classified.unresolvedReason !== undefined) {
+            unresolvedMessages.push({
+                selector,
+                receiverText: receiver.text,
+                reason: classified.unresolvedReason,
+                sourceMethodQualifiedName: method.qualifiedName,
+                sourceMethodId: method.nodeId,
+                filePath: method.filePath,
+                startLine: messageNode.startPosition.row,
+                startCol: messageNode.startPosition.column,
+            });
+        }
+        messages.push(fact);
+    });
+}
+export function collectObjectiveCFacts(tree, filePath) {
+    const containers = [];
+    const methods = [];
+    const members = [];
+    const functions = [];
+    const imports = [];
+    const messages = [];
+    const unresolvedMessages = [];
+    const membersByOwner = new Map();
+    const macroNames = new Set();
+    const classNames = new Set();
+    const addFunctionFact = (node) => {
+        for (const info of functionInfos(node)) {
+            const qualifiedName = objcFunctionQualifiedName(info.name, info.linkage, filePath);
+            const { startLine, endLine } = range(node);
+            functions.push({
+                name: info.name,
+                linkage: info.linkage,
+                qualifiedName,
+                nodeId: graphNodeId('Function', qualifiedName),
+                filePath,
+                startLine,
+                endLine,
+                ...(info.returnType !== undefined ? { returnType: info.returnType } : {}),
+                parameterTypes: info.parameterTypes,
+            });
+        }
+    };
+    walkNamedTree(tree.rootNode, (node) => {
+        if (node.type !== 'preproc_def' && node.type !== 'preproc_function_def')
+            return;
+        const name = macroName(node);
+        if (name !== undefined)
+            macroNames.add(name);
+    });
+    walkNamedTree(tree.rootNode, (node) => {
+        const container = parseContainer(node, filePath);
+        if (container?.kind === 'class')
+            classNames.add(container.name);
+    });
+    const addMemberType = (ownerQualifiedName, name, typeText) => {
+        const typeInfo = parseObjCType(typeText);
+        if (typeInfo === undefined)
+            return;
+        let byName = membersByOwner.get(ownerQualifiedName);
+        if (byName === undefined) {
+            byName = new Map();
+            membersByOwner.set(ownerQualifiedName, byName);
+        }
+        byName.set(name, typeInfo);
+    };
+    const collectContainerMemberTypes = (containerNode, container) => {
+        for (const inner of containerMemberNodes(containerNode)) {
+            if (inner.type === 'property_declaration') {
+                for (const prop of propertyInfos(inner)) {
+                    addMemberType(container.qualifiedName, prop.name, prop.type);
+                    if (container.hostClass !== undefined) {
+                        addMemberType(objcClassQualifiedName(container.hostClass), prop.name, prop.type);
+                    }
+                }
+            }
+            else if (inner.type === 'instance_variables') {
+                walkNamedTree(inner, (ivarNode) => {
+                    if (ivarNode.type !== 'instance_variable')
+                        return;
+                    for (const ivar of declarationNamesAndType(ivarNode)) {
+                        addMemberType(container.qualifiedName, ivar.name, ivar.type);
+                        if (container.hostClass !== undefined) {
+                            addMemberType(objcClassQualifiedName(container.hostClass), ivar.name, ivar.type);
+                        }
+                    }
+                });
+            }
+        }
+    };
+    const topLevelNodes = logicalTopLevelNodes(tree.rootNode);
+    for (const child of topLevelNodes) {
+        const container = parseContainer(child, filePath);
+        if (container !== null)
+            collectContainerMemberTypes(child, container);
+    }
+    for (const child of topLevelNodes) {
+        if (child.type === 'preproc_include') {
+            const rawNode = directNamedChildren(child).find((n) => n.type === 'string_literal' || n.type === 'system_lib_string');
+            if (rawNode !== undefined) {
+                const raw = rawNode.text;
+                const directive = child.text.trimStart().startsWith('#include') ? 'include' : 'import';
+                const { startLine, endLine } = range(child);
+                imports.push({
+                    kind: directive,
+                    raw,
+                    targetRaw: stripQuotes(raw),
+                    filePath,
+                    startLine,
+                    endLine,
+                });
+            }
+            continue;
+        }
+        if (child.type === 'module_import') {
+            const moduleName = directIdentifiers(child)
+                .map((n) => n.text)
+                .join('.');
+            const { startLine, endLine } = range(child);
+            imports.push({
+                kind: 'module',
+                raw: moduleName,
+                targetRaw: moduleName,
+                filePath,
+                startLine,
+                endLine,
+            });
+            continue;
+        }
+        const container = parseContainer(child, filePath);
+        if (container !== null) {
+            containers.push(container);
+            for (const inner of containerMemberNodes(child)) {
+                if (inner.type === 'method_declaration' || inner.type === 'method_definition') {
+                    const selector = methodSelector(inner);
+                    const { parameterTypes, parameterNames, typeBindings } = methodParameterInfo(inner);
+                    const kind = methodKind(inner);
+                    const qualifiedName = objcMethodQualifiedName(container.qualifiedName, kind, selector);
+                    const { startLine, endLine } = range(inner);
+                    const method = {
+                        name: selector,
+                        selector,
+                        methodKind: kind,
+                        ownerQualifiedName: container.qualifiedName,
+                        ownerName: container.name,
+                        ownerKind: container.kind,
+                        ...(container.hostClass !== undefined ? { hostClass: container.hostClass } : {}),
+                        qualifiedName,
+                        nodeId: graphNodeId('Method', qualifiedName),
+                        filePath,
+                        startLine,
+                        endLine,
+                        declarationRole: inner.type === 'method_definition' ? 'implementation' : 'declaration',
+                        ...(methodTypeText(inner) !== undefined ? { returnType: methodTypeText(inner) } : {}),
+                        parameterTypes,
+                        parameterNames,
+                    };
+                    methods.push(method);
+                    collectMethodMessages(inner, method, typeBindings, membersByOwner, macroNames, classNames, messages, unresolvedMessages);
+                }
+                else if (inner.type === 'property_declaration') {
+                    const { startLine, endLine } = range(inner);
+                    for (const prop of propertyInfos(inner)) {
+                        const qualifiedName = objcPropertyQualifiedName(container.qualifiedName, prop.name);
+                        members.push({
+                            kind: 'property',
+                            name: prop.name,
+                            qualifiedName,
+                            nodeId: graphNodeId('Property', qualifiedName),
+                            ownerQualifiedName: container.qualifiedName,
+                            ownerName: container.name,
+                            ownerKind: container.kind,
+                            ownerLabel: ownerLabel(container.kind),
+                            ...(container.hostClass !== undefined ? { hostClass: container.hostClass } : {}),
+                            ...(prop.type !== undefined ? { declaredType: prop.type } : {}),
+                            filePath,
+                            startLine,
+                            endLine,
+                        });
+                    }
+                }
+                else if (inner.type === 'instance_variables') {
+                    walkNamedTree(inner, (ivarNode) => {
+                        if (ivarNode.type !== 'instance_variable')
+                            return;
+                        const { startLine, endLine } = range(ivarNode);
+                        for (const ivar of declarationNamesAndType(ivarNode)) {
+                            const qualifiedName = objcIvarQualifiedName(container.qualifiedName, ivar.name);
+                            members.push({
+                                kind: 'ivar',
+                                name: ivar.name,
+                                qualifiedName,
+                                nodeId: graphNodeId('Variable', qualifiedName),
+                                ownerQualifiedName: container.qualifiedName,
+                                ownerName: container.name,
+                                ownerKind: container.kind,
+                                ownerLabel: ownerLabel(container.kind),
+                                ...(container.hostClass !== undefined ? { hostClass: container.hostClass } : {}),
+                                ...(ivar.type !== undefined ? { declaredType: ivar.type } : {}),
+                                filePath,
+                                startLine,
+                                endLine,
+                            });
+                        }
+                    });
+                }
+                else if (inner.type === 'implementation_definition') {
+                    const functionNode = directNamedChildren(inner).find((node) => node.type === 'function_definition');
+                    if (functionNode !== undefined) {
+                        addFunctionFact(functionNode);
+                        continue;
+                    }
+                    const methodNode = directNamedChildren(inner).find((n) => n.type === 'method_definition');
+                    if (methodNode !== undefined) {
+                        const selector = methodSelector(methodNode);
+                        const { parameterTypes, parameterNames, typeBindings } = methodParameterInfo(methodNode);
+                        const kind = methodKind(methodNode);
+                        const qualifiedName = objcMethodQualifiedName(container.qualifiedName, kind, selector);
+                        const { startLine, endLine } = range(methodNode);
+                        const method = {
+                            name: selector,
+                            selector,
+                            methodKind: kind,
+                            ownerQualifiedName: container.qualifiedName,
+                            ownerName: container.name,
+                            ownerKind: container.kind,
+                            ...(container.hostClass !== undefined ? { hostClass: container.hostClass } : {}),
+                            qualifiedName,
+                            nodeId: graphNodeId('Method', qualifiedName),
+                            filePath,
+                            startLine,
+                            endLine,
+                            declarationRole: 'implementation',
+                            ...(methodTypeText(methodNode) !== undefined
+                                ? { returnType: methodTypeText(methodNode) }
+                                : {}),
+                            parameterTypes,
+                            parameterNames,
+                        };
+                        methods.push(method);
+                        collectMethodMessages(methodNode, method, typeBindings, membersByOwner, macroNames, classNames, messages, unresolvedMessages);
+                    }
+                }
+            }
+            continue;
+        }
+        if (child.type === 'function_definition' || child.type === 'declaration') {
+            addFunctionFact(child);
+        }
+    }
+    return {
+        providerVersion: OBJECTIVE_C_PROVIDER_VERSION,
+        grammarPackage: OBJECTIVE_C_GRAMMAR_PACKAGE,
+        grammarVersion: OBJECTIVE_C_GRAMMAR_VERSION,
+        filePath,
+        containers,
+        methods,
+        members,
+        functions,
+        imports,
+        messages,
+        unresolvedMessages,
+    };
+}
+function semanticNode(label, id, name, qualifiedName, filePath, startLine, endLine, extras = {}) {
+    return {
+        id,
+        label,
+        properties: {
+            name,
+            filePath,
+            startLine,
+            endLine,
+            language: SupportedLanguages.ObjectiveC,
+            isExported: true,
+            qualifiedName,
+            objectiveCProviderVersion: OBJECTIVE_C_PROVIDER_VERSION,
+            objectiveCGrammar: `${OBJECTIVE_C_GRAMMAR_PACKAGE}@${OBJECTIVE_C_GRAMMAR_VERSION}`,
+            ...extras,
+        },
+    };
+}
+function relationship(type, sourceId, targetId, reason) {
+    return {
+        id: generateId(type, `${sourceId}->${targetId}:${reason}`),
+        sourceId,
+        targetId,
+        type,
+        confidence: 1,
+        reason,
+    };
+}
+function implementationEvidenceNode(qualifiedName, name, filePath, startLine, endLine, extras) {
+    return semanticNode('CodeElement', graphNodeId('CodeElement', qualifiedName), name, qualifiedName, filePath, startLine, endLine, {
+        objectiveCKind: 'implementation-evidence',
+        ...extras,
+    });
+}
+export function buildObjectiveCSemanticGraph(facts) {
+    const nodes = [];
+    const relationships = [];
+    const symbols = [];
+    const fileId = generateId('File', facts.filePath);
+    for (const container of facts.containers) {
+        nodes.push(semanticNode(container.label, container.nodeId, container.name, container.qualifiedName, facts.filePath, container.startLine, container.endLine, {
+            objectiveCKind: container.kind,
+            declarationRole: container.declarationRole,
+            ...(container.superclass !== undefined ? { superclass: container.superclass } : {}),
+            ...(container.protocols.length > 0 ? { protocols: [...container.protocols] } : {}),
+            ...(container.hostClass !== undefined ? { hostClass: container.hostClass } : {}),
+            ...(container.categoryName !== undefined ? { categoryName: container.categoryName } : {}),
+        }));
+        relationships.push(relationship('DEFINES', fileId, container.nodeId, 'objc-definition'));
+        if (container.declarationRole === 'implementation') {
+            const qualifiedName = `objc:implementation:${container.qualifiedName}:${facts.filePath}:${container.startLine}`;
+            const evidenceId = graphNodeId('CodeElement', qualifiedName);
+            nodes.push(implementationEvidenceNode(qualifiedName, `@implementation ${container.name}`, facts.filePath, container.startLine, container.endLine, {
+                implementationKind: container.kind,
+                targetQualifiedName: container.qualifiedName,
+            }));
+            relationships.push(relationship('DEFINES', fileId, evidenceId, 'objc: implementation evidence'));
+            relationships.push(relationship('DECLARES', evidenceId, container.nodeId, 'objc: implementation of merged symbol'));
+        }
+        symbols.push({
+            filePath: facts.filePath,
+            name: container.name,
+            nodeId: container.nodeId,
+            type: container.label,
+            qualifiedName: container.qualifiedName,
+        });
+    }
+    for (const method of facts.methods) {
+        nodes.push(semanticNode('Method', method.nodeId, method.selector, method.qualifiedName, facts.filePath, method.startLine, method.endLine, {
+            selector: method.selector,
+            methodKind: method.methodKind,
+            objectiveCOwner: method.ownerQualifiedName,
+            objectiveCOwnerName: method.ownerName,
+            description: `${method.ownerName} ${method.methodKind}${method.selector}`,
+            declarationRole: method.declarationRole,
+            parameterCount: method.parameterTypes.length,
+            parameterTypes: [...method.parameterTypes],
+            ...(method.returnType !== undefined ? { returnType: method.returnType } : {}),
+            ...(method.hostClass !== undefined ? { hostClass: method.hostClass } : {}),
+        }));
+        const ownerId = graphNodeId(method.ownerKind === 'class'
+            ? 'Class'
+            : method.ownerKind === 'protocol'
+                ? 'Protocol'
+                : 'Category', method.ownerQualifiedName);
+        relationships.push(relationship('HAS_METHOD', ownerId, method.nodeId, 'objc-owner-method'));
+        if (method.declarationRole === 'implementation') {
+            const qualifiedName = `objc:method-implementation:${method.qualifiedName}:${facts.filePath}:${method.startLine}`;
+            const evidenceId = graphNodeId('CodeElement', qualifiedName);
+            nodes.push(implementationEvidenceNode(qualifiedName, `${method.methodKind}[${method.ownerName} ${method.selector}] implementation`, facts.filePath, method.startLine, method.endLine, {
+                implementationKind: 'method',
+                targetQualifiedName: method.qualifiedName,
+                selector: method.selector,
+                methodKind: method.methodKind,
+                objectiveCOwner: method.ownerQualifiedName,
+            }));
+            relationships.push(relationship('DEFINES', fileId, evidenceId, 'objc: implementation evidence'));
+            relationships.push(relationship('DECLARES', evidenceId, method.nodeId, 'objc: implementation of merged symbol'));
+        }
+        if (method.hostClass !== undefined) {
+            relationships.push(relationship('HAS_METHOD', graphNodeId('Class', objcClassQualifiedName(method.hostClass)), method.nodeId, 'objc-category-host-method'));
+        }
+        symbols.push({
+            filePath: facts.filePath,
+            name: method.selector,
+            nodeId: method.nodeId,
+            type: 'Method',
+            qualifiedName: method.qualifiedName,
+            parameterCount: method.parameterTypes.length,
+            requiredParameterCount: method.parameterTypes.length,
+            parameterTypes: [...method.parameterTypes],
+            ...(method.returnType !== undefined ? { returnType: method.returnType } : {}),
+            ownerId,
+            isStatic: method.methodKind === '+',
+        });
+    }
+    for (const member of facts.members) {
+        const label = member.kind === 'property' ? 'Property' : 'Variable';
+        nodes.push(semanticNode(label, member.nodeId, member.name, member.qualifiedName, facts.filePath, member.startLine, member.endLine, {
+            objectiveCKind: member.kind,
+            ...(member.declaredType !== undefined ? { declaredType: member.declaredType } : {}),
+        }));
+        relationships.push(relationship(member.kind === 'property' ? 'HAS_PROPERTY' : 'HAS_PROPERTY', graphNodeId(member.ownerLabel, member.ownerQualifiedName), member.nodeId, `objc-${member.kind}`));
+        if (member.hostClass !== undefined) {
+            relationships.push(relationship('HAS_PROPERTY', graphNodeId('Class', objcClassQualifiedName(member.hostClass)), member.nodeId, `objc-category-host-${member.kind}`));
+        }
+        symbols.push({
+            filePath: facts.filePath,
+            name: member.name,
+            nodeId: member.nodeId,
+            type: label,
+            qualifiedName: member.qualifiedName,
+            ...(member.declaredType !== undefined ? { declaredType: member.declaredType } : {}),
+            ownerId: graphNodeId(member.ownerLabel, member.ownerQualifiedName),
+        });
+    }
+    for (const fn of facts.functions) {
+        nodes.push(semanticNode('Function', fn.nodeId, fn.name, fn.qualifiedName, facts.filePath, fn.startLine, fn.endLine, {
+            parameterCount: fn.parameterTypes.length,
+            parameterTypes: [...fn.parameterTypes],
+            linkage: fn.linkage,
+            ...(fn.returnType !== undefined ? { returnType: fn.returnType } : {}),
+        }));
+        relationships.push(relationship('DEFINES', fileId, fn.nodeId, 'objc-c-function'));
+        symbols.push({
+            filePath: facts.filePath,
+            name: fn.name,
+            nodeId: fn.nodeId,
+            type: 'Function',
+            qualifiedName: fn.qualifiedName,
+            parameterCount: fn.parameterTypes.length,
+            parameterTypes: [...fn.parameterTypes],
+            ...(fn.returnType !== undefined ? { returnType: fn.returnType } : {}),
+        });
+    }
+    for (const imp of facts.imports) {
+        const qualifiedName = `objc:import:${facts.filePath}:${imp.startLine}:${imp.kind}:${imp.targetRaw}`;
+        const id = graphNodeId('Import', qualifiedName);
+        nodes.push(semanticNode('Import', id, imp.targetRaw, qualifiedName, facts.filePath, imp.startLine, imp.endLine, {
+            objectiveCKind: 'import',
+            importKind: imp.kind,
+            raw: imp.raw,
+            targetRaw: imp.targetRaw,
+        }));
+        relationships.push(relationship('DEFINES', fileId, id, 'objc-import'));
+        symbols.push({
+            filePath: facts.filePath,
+            name: imp.targetRaw,
+            nodeId: id,
+            type: 'Import',
+            qualifiedName,
+        });
+    }
+    for (const unresolved of facts.unresolvedMessages) {
+        const qn = objcUnresolvedMessageQualifiedName(facts.filePath, unresolved.startLine, unresolved.startCol, unresolved.selector);
+        const id = graphNodeId('CodeElement', qn);
+        nodes.push(semanticNode('CodeElement', id, `[${unresolved.receiverText} ${unresolved.selector}] unresolved: ${unresolved.reason}`, qn, facts.filePath, unresolved.startLine, unresolved.startLine, {
+            objectiveCKind: 'unresolved-message',
+            selector: unresolved.selector,
+            receiver: unresolved.receiverText,
+            resolution: 'unresolved',
+        }));
+        relationships.push(relationship('DEFINES', fileId, id, `objc-unresolved-message: ${unresolved.reason}`));
+        symbols.push({
+            filePath: facts.filePath,
+            name: `[${unresolved.receiverText} ${unresolved.selector}]`,
+            nodeId: id,
+            type: 'CodeElement',
+            qualifiedName: qn,
+        });
+    }
+    return { nodes, relationships, symbols };
+}
+function captureAt(name, text, startLine, endLine) {
+    return {
+        name,
+        text,
+        range: {
+            startLine: startLine + 1,
+            startCol: 0,
+            endLine: endLine + 1,
+            endCol: 0,
+        },
+    };
+}
+export function buildObjectiveCScopeCaptures(facts, root) {
+    const captures = [
+        {
+            '@scope.module': nodeToCapture('@scope.module', root),
+        },
+    ];
+    const seenDeclarations = new Set();
+    for (const container of facts.containers) {
+        const kind = declarationCaptureKind(container.kind);
+        if (kind === undefined)
+            continue;
+        if (!seenDeclarations.add(`${kind}:${container.qualifiedName}`))
+            continue;
+        captures.push(declarationMatch(kind, container.kind === 'category' || container.kind === 'extension'
+            ? (container.categoryName ?? container.name)
+            : container.name, container.qualifiedName, container.startLine, container.endLine));
+    }
+    for (const fn of facts.functions) {
+        if (!seenDeclarations.add(`function:${fn.qualifiedName}`))
+            continue;
+        captures.push(declarationMatch('function', fn.name, fn.qualifiedName, fn.startLine, fn.endLine));
+    }
+    for (const imp of facts.imports) {
+        const anchor = captureAt('@import.statement', imp.raw, imp.startLine, imp.endLine);
+        const sourceText = isSystemHeaderSpelling(imp.raw) ? imp.raw : imp.targetRaw;
+        captures.push({
+            '@import.statement': anchor,
+            '@import.source': {
+                ...anchor,
+                name: '@import.source',
+                text: sourceText,
+            },
+            '@import.name': { ...anchor, name: '@import.name', text: sourceText },
+            '@import.kind': { ...anchor, name: '@import.kind', text: imp.kind },
+        });
+    }
+    return captures;
+}
+function declarationCaptureKind(kind) {
+    if (kind === 'extension')
+        return undefined;
+    return kind;
+}
+function declarationMatch(kind, name, qualifiedName, startLine, endLine) {
+    const anchor = captureAt(`@declaration.${kind}`, name, startLine, endLine);
+    return {
+        [`@declaration.${kind}`]: anchor,
+        '@declaration.name': { ...anchor, name: '@declaration.name', text: name },
+        '@declaration.qualified_name': {
+            ...anchor,
+            name: '@declaration.qualified_name',
+            text: qualifiedName,
+        },
+    };
+}