@contractkit/prettier-plugin 0.8.1

package/src/index.ts

@@ -0,0 +1,46 @@
+import type { Plugin } from 'prettier';
+import { builders } from 'prettier/doc';
+import { parseCk, DiagnosticCollector } from '@contractkit/core';
+import type { CkRootNode } from '@contractkit/core';
+import { printCk } from './print-ck.js';
+
+const { hardline, join } = builders;
+
+function toDoc(text: string) {
+    const lines = text.trimEnd().split('\n');
+    return join(hardline, lines);
+}
+
+const plugin: Plugin<CkRootNode> = {
+    languages: [
+        {
+            name: 'ContractDSL',
+            parsers: ['contract-ck'],
+            extensions: ['.ck'],
+            vscodeLanguageIds: ['contract-ck'],
+        },
+    ],
+
+    parsers: {
+        'contract-ck': {
+            parse(text, _options) {
+                const diag = new DiagnosticCollector();
+                return parseCk(text, '<stdin>', diag);
+            },
+            astFormat: 'contract-ck',
+            locStart: () => 0,
+            locEnd: _node => 0,
+        },
+    },
+
+    printers: {
+        'contract-ck': {
+            print(path, options) {
+                const node = path.node as CkRootNode;
+                return toDoc(printCk(node, options.printWidth));
+            },
+        },
+    },
+};
+
+export default plugin;

package/src/print-ck.ts

@@ -0,0 +1,95 @@
+import type { CkRootNode, OpResponseHeaderNode } from '@contractkit/core';
+import { printModelDecl } from './print-contract.js';
+import { printRoute, printSecurity, type CommentBlock } from './print-operation.js';
+import { printType } from './print-type.js';
+import { INDENT } from './indent.js';
+
+export const DEFAULT_PRINT_WIDTH = 80;
+
+// ─── Options block ──────────────────────────────────────────────────────────
+
+function printOptionsBlock(ast: CkRootNode): string | null {
+    const hasMeta = Object.keys(ast.meta).length > 0;
+    const hasServices = Object.keys(ast.services).length > 0;
+    const hasSecurity = ast.security !== undefined;
+    const hasRequestHeaders = (ast.requestHeaders?.length ?? 0) > 0;
+    const hasResponseHeaders = (ast.responseHeaders?.length ?? 0) > 0;
+
+    if (!hasMeta && !hasServices && !hasSecurity && !hasRequestHeaders && !hasResponseHeaders) return null;
+
+    const lines: string[] = ['options {'];
+
+    if (hasMeta) {
+        lines.push(`${INDENT}keys: {`);
+        for (const [key, value] of Object.entries(ast.meta)) {
+            const v = value.startsWith('#') || value.includes(' ') ? `"${value}"` : value;
+            lines.push(`${INDENT}${INDENT}${key}: ${v}`);
+        }
+        lines.push(`${INDENT}}`);
+    }
+
+    if (hasServices) {
+        lines.push(`${INDENT}services: {`);
+        for (const [key, value] of Object.entries(ast.services)) {
+            const v = value.startsWith('#') || value.includes(' ') ? `"${value}"` : value;
+            lines.push(`${INDENT}${INDENT}${key}: ${v}`);
+        }
+        lines.push(`${INDENT}}`);
+    }
+
+    if (hasRequestHeaders) {
+        lines.push(...printOptionsHeaderScope('request', ast.requestHeaders!));
+    }
+
+    if (hasResponseHeaders) {
+        lines.push(...printOptionsHeaderScope('response', ast.responseHeaders!));
+    }
+
+    if (hasSecurity) {
+        lines.push(...printSecurity(ast.security!, INDENT, INDENT + INDENT));
+    }
+
+    lines.push('}');
+    return lines.join('\n');
+}
+
+function printOptionsHeaderScope(keyword: 'request' | 'response', headers: OpResponseHeaderNode[]): string[] {
+    const I2 = INDENT + INDENT;
+    const I3 = INDENT + INDENT + INDENT;
+    const lines = [`${INDENT}${keyword}: {`, `${I2}headers: {`];
+    for (const h of headers) {
+        const opt = h.optional ? '?' : '';
+        const trail = h.description ? ` # ${h.description}` : '';
+        lines.push(`${I3}${h.name}${opt}: ${printType(h.type)}${trail}`);
+    }
+    lines.push(`${I2}}`);
+    lines.push(`${INDENT}}`);
+    return lines;
+}
+
+// ─── CK file printer ───────────────────────────────────────────────────────
+
+export function printCk(ast: CkRootNode, printWidth: number = DEFAULT_PRINT_WIDTH): string {
+    const parts: string[] = [];
+
+    // Options block
+    const options = printOptionsBlock(ast);
+    if (options) parts.push(options);
+
+    // Contracts (models)
+    for (const model of ast.models) {
+        if (parts.length > 0) parts.push('');
+        parts.push(`contract ${printModelDecl(model, printWidth)}`);
+    }
+
+    // Operations (routes)
+    const emptyBlocks: CommentBlock[] = [];
+    const emptyIdx = { value: 0 };
+    for (const route of ast.routes) {
+        if (parts.length > 0) parts.push('');
+        const modPart = route.modifiers?.length ? `(${route.modifiers[0]})` : '';
+        parts.push(`operation${modPart} ${printRoute(route, emptyBlocks, emptyIdx, Infinity)}`);
+    }
+
+    return parts.join('\n') + '\n';
+}

package/src/print-contract.ts

@@ -0,0 +1,69 @@
+import type { ModelNode } from '@contractkit/core';
+import { printField, printInlineObjectExpanded, extractTrailingInlineObject, printType, printEnumExpanded } from './print-type.js';
+import { INDENT } from './indent.js';
+
+// ─── Model declaration ───────────────────────────────────────────────────────
+
+export function printModelDecl(model: ModelNode, printWidth: number = 80): string {
+    // Type alias form: Name : typeExpression
+    if (model.type !== undefined) {
+        return printTypeAlias(model, printWidth);
+    }
+
+    // Regular model with fields (possibly inherited)
+    const commentSuffix = model.description ? ` # ${model.description}` : '';
+    const modifiers = [
+        model.deprecated ? 'deprecated' : '',
+        model.inputCase || model.outputCase
+            ? `format(${[model.inputCase ? `input=${model.inputCase}` : '', model.outputCase ? `output=${model.outputCase}` : ''].filter(Boolean).join(', ')})`
+            : '',
+        model.mode ? `mode(${model.mode})` : '',
+    ]
+        .filter(Boolean)
+        .join(' ');
+    const modePrefix = modifiers ? `${modifiers} ` : '';
+    const baseChain = model.bases && model.bases.length > 0 ? `${model.bases.join(' & ')} & ` : '';
+    const header = `${modePrefix}${model.name}: ${baseChain}{${commentSuffix}`;
+
+    const lines: string[] = [header];
+    for (const field of model.fields) {
+        lines.push(printField(field, INDENT, printWidth));
+    }
+    lines.push('}');
+    return lines.join('\n');
+}
+
+function printTypeAlias(model: ModelNode, printWidth: number): string {
+    const type = model.type!;
+    const commentSuffix = model.description ? ` # ${model.description}` : '';
+    const modifiers = [
+        model.deprecated ? 'deprecated' : '',
+        model.inputCase || model.outputCase
+            ? `format(${[model.inputCase ? `input=${model.inputCase}` : '', model.outputCase ? `output=${model.outputCase}` : ''].filter(Boolean).join(', ')})`
+            : '',
+        model.mode ? `mode(${model.mode})` : '',
+    ]
+        .filter(Boolean)
+        .join(' ');
+    const modePrefix = modifiers ? `${modifiers} ` : '';
+
+    // If the type ends with an inline brace object, expand it as a pseudo-model block.
+    const trailing = extractTrailingInlineObject(type);
+    if (trailing) {
+        const { prefix, inlineObj } = trailing;
+        const modePart = inlineObj.mode ? `mode(${inlineObj.mode}) ` : '';
+        const header = prefix
+            ? `${modePrefix}${model.name}: ${prefix} & ${modePart}{${commentSuffix}`
+            : `${modePrefix}${model.name}: ${modePart}{${commentSuffix}`;
+        const lines: string[] = [header, ...printInlineObjectExpanded(inlineObj, INDENT, printWidth), '}'];
+        return lines.join('\n');
+    }
+
+    // Simple type alias — single line, unless it's a long enum.
+    // Note: the contract prefix "contract " (9 chars) is prepended by the caller.
+    const singleLine = `${modePrefix}${model.name}: ${printType(type)}${commentSuffix}`;
+    if (type.kind === 'enum' && 'contract '.length + singleLine.length > printWidth) {
+        return `${modePrefix}${model.name}: ${printEnumExpanded(type.values, '')}${commentSuffix}`;
+    }
+    return singleLine;
+}

package/src/print-operation.ts

@@ -0,0 +1,242 @@
+import type {
+    OpRouteNode,
+    OpOperationNode,
+    OpResponseNode,
+    ParamSource,
+    SecurityNode,
+    SecurityFields,
+    ContractTypeNode,
+    ObjectMode,
+} from '@contractkit/core';
+import { SECURITY_NONE } from '@contractkit/core';
+import { printType, formatDefault } from './print-type.js';
+import { INDENT } from './indent.js';
+
+const I1 = INDENT;
+const I2 = INDENT.repeat(2);
+const I3 = INDENT.repeat(3);
+const I4 = INDENT.repeat(4);
+
+// ─── Orphan comment helpers ──────────────────────────────────────────────────
+
+type CommentEntry = { line: number; text: string };
+export type CommentBlock = { startLine: number; lines: string[] };
+
+/** Group sorted orphan comment entries into consecutive-line blocks. */
+export function groupComments(entries: CommentEntry[]): CommentBlock[] {
+    const blocks: CommentBlock[] = [];
+    let current: CommentBlock | null = null;
+    for (const { line, text } of entries) {
+        if (current && line === current.startLine + current.lines.length) {
+            current.lines.push(text);
+        } else {
+            if (current) blocks.push(current);
+            current = { startLine: line, lines: [text] };
+        }
+    }
+    if (current) blocks.push(current);
+    return blocks;
+}
+
+/**
+ * Emit any comment blocks whose startLine is < beforeLine.
+ * Lines are emitted verbatim — they already carry their original indentation.
+ */
+export function flushBlocks(out: string[], blocks: CommentBlock[], idx: { value: number }, beforeLine: number, _indent = '') {
+    while (idx.value < blocks.length && blocks[idx.value]!.startLine < beforeLine) {
+        for (const l of blocks[idx.value]!.lines) out.push(l);
+        idx.value++;
+    }
+}
+
+// ─── Route ───────────────────────────────────────────────────────────────────
+
+export function printRoute(route: OpRouteNode, blocks: CommentBlock[], idx: { value: number }, nextRouteStart: number): string {
+    const lines: string[] = [];
+    const commentSuffix = route.description ? ` # ${route.description}` : '';
+    lines.push(`${route.path}: {${commentSuffix}`);
+
+    if (route.params !== undefined) {
+        lines.push(...printParamsBlock(route.params, I1, route.paramsMode));
+    }
+
+    if (route.security !== undefined) {
+        lines.push(...printSecurity(route.security, I1, I2));
+    }
+
+    for (const op of route.operations) {
+        // Flush comment blocks that appear before this operation (inside the route)
+        flushBlocks(lines, blocks, idx, op.loc.line, I1);
+        lines.push(...printOperation(op));
+    }
+
+    // Flush comment blocks between last operation and the next route
+    flushBlocks(lines, blocks, idx, nextRouteStart, I1);
+
+    lines.push('}');
+    return lines.join('\n');
+}
+
+// ─── Params block ────────────────────────────────────────────────────────────
+
+function printParamsBlock(source: ParamSource, indent: string, mode?: ObjectMode): string[] {
+    const prefix = mode ? `mode(${mode}) ` : '';
+    if (source.kind === 'ref') {
+        return [`${indent}${prefix}params: ${source.name}`];
+    }
+    if (source.kind === 'params') {
+        const lines: string[] = [`${indent}${prefix}params: {`];
+        const inner = indent + INDENT;
+        for (const p of source.nodes) {
+            const opt = p.optional ? '?' : '';
+            let t = printType(p.type);
+            if (p.nullable) t += ' | null';
+            const def = p.default !== undefined ? ` = ${formatDefault(p.default)}` : '';
+            const comment = p.description ? ` # ${p.description}` : '';
+            lines.push(`${inner}${p.name}${opt}: ${t}${def}${comment}`);
+        }
+        lines.push(`${indent}}`);
+        return lines;
+    }
+    // ContractTypeNode
+    return [`${indent}${prefix}params: ${printType(source.node)}`];
+}
+
+// ─── HTTP operation ──────────────────────────────────────────────────────────
+
+function printOperation(op: OpOperationNode): string[] {
+    const lines: string[] = [];
+    const commentSuffix = op.description ? ` # ${op.description}` : '';
+    const modPart = op.modifiers?.length ? `(${op.modifiers[0]})` : '';
+    lines.push(`${I1}${op.method}${modPart}: {${commentSuffix}`);
+
+    if (op.name) lines.push(`${I2}name: ${op.name}`);
+    if (op.service) lines.push(`${I2}service: ${op.service}`);
+    if (op.sdk) lines.push(`${I2}sdk: ${op.sdk}`);
+    if (op.signature) {
+        const comment = op.signatureDescription ? ` # ${op.signatureDescription}` : '';
+        lines.push(`${I2}signature: ${formatSignatureValue(op.signature)}${comment}`);
+    }
+    if (op.security !== undefined) lines.push(...printSecurity(op.security));
+    if (op.query !== undefined) lines.push(...printQueryOrHeaders('query', op.query, op.queryMode));
+    if (op.requestHeadersOptOut) {
+        lines.push(`${I2}headers: none`);
+    } else if (op.headers !== undefined) {
+        lines.push(...printQueryOrHeaders('headers', op.headers, op.headersMode));
+    }
+    if (op.request) {
+        lines.push(`${I2}request: {`);
+        for (const body of op.request.bodies) {
+            lines.push(...printContentTypeLine(body.contentType, body.bodyType, I3));
+        }
+        lines.push(`${I2}}`);
+    }
+    if (op.responses.length > 0) {
+        lines.push(...printResponseBlock(op.responses));
+    }
+
+    lines.push(`${I1}}`);
+    return lines;
+}
+
+// ─── Security ────────────────────────────────────────────────────────────────
+
+/** Print a signature key: unquoted when it's a plain identifier, quoted otherwise. */
+function formatSignatureValue(value: string): string {
+    return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(value) ? value : `"${value}"`;
+}
+
+// indent: indentation for the `security` keyword line
+// innerIndent: indentation for field lines inside the block
+export function printSecurity(security: SecurityNode, indent = I2, innerIndent = I3): string[] {
+    if (security === SECURITY_NONE) return [`${indent}security: none`];
+    const fields = security as SecurityFields;
+    const hasRoles = fields.roles && fields.roles.length > 0;
+    if (!hasRoles) return [];
+    const lines = [`${indent}security: {`];
+    const comment = fields.rolesDescription ? ` # ${fields.rolesDescription}` : '';
+    lines.push(`${innerIndent}roles: ${fields.roles!.join(' ')}${comment}`);
+    lines.push(`${indent}}`);
+    return lines;
+}
+
+// ─── Query / headers ─────────────────────────────────────────────────────────
+
+function printQueryOrHeaders(keyword: 'query' | 'headers', source: ParamSource, mode?: ObjectMode): string[] {
+    const prefix = mode ? `mode(${mode}) ` : '';
+    if (source.kind === 'ref') {
+        return [`${I2}${prefix}${keyword}: ${source.name}`];
+    }
+    if (source.kind === 'params') {
+        if (source.nodes.length === 0) return [];
+        const lines: string[] = [`${I2}${prefix}${keyword}: {`];
+        for (const p of source.nodes) {
+            const opt = p.optional ? '?' : '';
+            let t = printType(p.type);
+            if (p.nullable) t += ' | null';
+            const def = p.default !== undefined ? ` = ${formatDefault(p.default)}` : '';
+            const comment = p.description ? ` # ${p.description}` : '';
+            lines.push(`${I3}${p.name}${opt}: ${t}${def}${comment}`);
+        }
+        lines.push(`${I2}}`);
+        return lines;
+    }
+    // ContractTypeNode (e.g. intersection)
+    return [`${I2}${prefix}${keyword}: ${printType(source.node)}`];
+}
+
+// ─── Content-type line ───────────────────────────────────────────────────────
+
+/** Print a `contentType: bodyType` line, expanding inline brace objects onto separate lines. */
+function printContentTypeLine(contentType: string, bodyType: ContractTypeNode, lineIndent: string): string[] {
+    if (bodyType.kind === 'inlineObject') {
+        const fieldIndent = lineIndent + INDENT;
+        const lines: string[] = [`${lineIndent}${contentType}: {`];
+        for (const f of bodyType.fields) {
+            const opt = f.optional ? '?' : '';
+            let t = printType(f.type);
+            if (f.nullable) t += ' | null';
+            const def = f.default !== undefined ? ` = ${formatDefault(f.default)}` : '';
+            const comment = f.description ? ` # ${f.description}` : '';
+            lines.push(`${fieldIndent}${f.name}${opt}: ${t}${def}${comment}`);
+        }
+        lines.push(`${lineIndent}}`);
+        return lines;
+    }
+    return [`${lineIndent}${contentType}: ${printType(bodyType)}`];
+}
+
+// ─── Response block ──────────────────────────────────────────────────────────
+
+function printResponseBlock(responses: OpResponseNode[]): string[] {
+    const lines: string[] = [`${I2}response: {`];
+
+    for (const resp of responses) {
+        const hasBody = resp.contentType && resp.bodyType;
+        const hasHeaders = resp.headers && resp.headers.length > 0;
+        const optOut = resp.headersOptOut;
+        if (hasBody || hasHeaders || optOut) {
+            lines.push(`${I3}${resp.statusCode}: {`);
+            if (hasBody) {
+                lines.push(...printContentTypeLine(resp.contentType!, resp.bodyType!, I4));
+            }
+            if (optOut) {
+                lines.push(`${I4}headers: none`);
+            } else if (hasHeaders) {
+                lines.push(`${I4}headers: {`);
+                for (const h of resp.headers!) {
+                    const opt = h.optional ? '?' : '';
+                    const trail = h.description ? ` # ${h.description}` : '';
+                    lines.push(`${I4}${INDENT}${h.name}${opt}: ${printType(h.type)}${trail}`);
+                }
+                lines.push(`${I4}}`);
+            }
+            lines.push(`${I3}}`);
+        } else {
+            lines.push(`${I3}${resp.statusCode}:`);
+        }
+    }
+
+    lines.push(`${I2}}`);
+    return lines;
+}

package/src/print-type.ts

@@ -0,0 +1,142 @@
+import type { ContractTypeNode, FieldNode, InlineObjectTypeNode } from '@contractkit/core';
+import { INDENT } from './indent.js';
+
+// ─── Type expression printer ────────────────────────────────────────────────
+
+export function printType(type: ContractTypeNode): string {
+    switch (type.kind) {
+        case 'scalar': {
+            const constraints: string[] = [];
+            if (type.format !== undefined) {
+                // Print unquoted when format contains only safe chars; quote otherwise
+                const fmt = type.format;
+                constraints.push(/^[a-zA-Z0-9\-.:/]+$/.test(fmt) ? fmt : `"${fmt}"`);
+            }
+            if (type.min !== undefined) constraints.push(`min=${type.min}`);
+            if (type.max !== undefined) constraints.push(`max=${type.max}`);
+            if (type.len !== undefined) constraints.push(`len=${type.len}`);
+            if (type.regex !== undefined) constraints.push(`regex=/${type.regex}/`);
+            return constraints.length > 0 ? `${type.name}(${constraints.join(', ')})` : type.name;
+        }
+        case 'array': {
+            const args: string[] = [printType(type.item)];
+            if (type.min !== undefined) args.push(`min=${type.min}`);
+            if (type.max !== undefined) args.push(`max=${type.max}`);
+            return `array(${args.join(', ')})`;
+        }
+        case 'tuple':
+            return `tuple(${type.items.map(printType).join(', ')})`;
+        case 'record':
+            return `record(${printType(type.key)}, ${printType(type.value)})`;
+        case 'enum':
+            return `enum(${type.values.join(', ')})`;
+        case 'literal':
+            return typeof type.value === 'string' ? `literal("${type.value}")` : `literal(${type.value})`;
+        case 'union':
+            return type.members.map(printType).join(' | ');
+        case 'discriminatedUnion':
+            return `discriminated(by=${type.discriminator}, ${type.members.map(printType).join(' | ')})`;
+        case 'intersection':
+            return type.members.map(printType).join(' & ');
+        case 'ref':
+            return type.name;
+        case 'inlineObject':
+            return printInlineObjectCompact(type);
+        case 'lazy':
+            return `lazy(${printType(type.inner)})`;
+    }
+}
+
+/** Compact single-line form — used when inline object appears nested inside another type. */
+function printInlineObjectCompact(obj: InlineObjectTypeNode): string {
+    const prefix = obj.mode ? `mode(${obj.mode}) ` : '';
+    if (obj.fields.length === 0) return `${prefix}{}`;
+    const parts = obj.fields.map(f => {
+        const opt = f.optional ? '?' : '';
+        let t = printType(f.type);
+        if (f.nullable) t += ' | null';
+        return `${f.name}${opt}: ${t}`;
+    });
+    return `${prefix}{ ${parts.join(', ')} }`;
+}
+
+/** Multi-line enum form — one value per line, used when single-line would exceed print width. */
+export function printEnumExpanded(values: string[], indent: string): string {
+    const innerIndent = indent + INDENT;
+    return `enum(\n${values.map(v => `${innerIndent}${v}`).join(',\n')}\n${indent})`;
+}
+
+// ─── Field printer ──────────────────────────────────────────────────────────
+
+/** Print a full field declaration, including visibility, default, and inline comment.
+ * Modifier order is canonical: override → deprecated → readonly|writeonly → type. */
+export function printField(field: FieldNode, indent: string, printWidth: number = 80): string {
+    const opt = field.optional ? '?' : '';
+    const ovr = field.override ? 'override ' : '';
+    const dep = field.deprecated ? 'deprecated ' : '';
+    const vis = field.visibility !== 'normal' ? `${field.visibility} ` : '';
+    const mods = `${ovr}${dep}${vis}`;
+    const def = field.default !== undefined ? ` = ${formatDefault(field.default)}` : '';
+    const comment = field.description ? ` # ${field.description}` : '';
+    const innerIndent = indent + INDENT;
+
+    // Expand inline object types to multi-line — same rule as type aliases.
+    // Only when there's no default and no nullable union (those can't split cleanly).
+    if (!field.nullable && field.default === undefined) {
+        const trailing = extractTrailingInlineObject(field.type);
+        if (trailing) {
+            const { prefix, inlineObj } = trailing;
+            const modePart = inlineObj.mode ? `mode(${inlineObj.mode}) ` : '';
+            const header = prefix
+                ? `${indent}${field.name}${opt}: ${mods}${prefix} & ${modePart}{${comment}`
+                : `${indent}${field.name}${opt}: ${mods}${modePart}{${comment}`;
+            return [header, ...printInlineObjectExpanded(inlineObj, innerIndent, printWidth), `${indent}}`].join('\n');
+        }
+    }
+
+    let typeStr = printType(field.type);
+    if (field.nullable) typeStr += ' | null';
+    const fullLine = `${indent}${field.name}${opt}: ${mods}${typeStr}${def}${comment}`;
+    if (field.type.kind === 'enum' && !field.nullable && field.default === undefined && fullLine.length > printWidth) {
+        const enumStr = printEnumExpanded(field.type.values, indent);
+        return `${indent}${field.name}${opt}: ${mods}${enumStr}${comment}`;
+    }
+    return fullLine;
+}
+
+/** Print inline-object fields expanded (used when an inline brace object trails a type alias). */
+export function printInlineObjectExpanded(obj: InlineObjectTypeNode, indent: string, printWidth: number = 80): string[] {
+    return obj.fields.map(f => printField(f, indent, printWidth));
+}
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+/** Format a default value: quote strings that aren't valid bare identifiers. */
+export function formatDefault(val: string | number | boolean): string {
+    if (typeof val === 'number' || typeof val === 'boolean') return String(val);
+    // If it looks like a bare identifier (enum value, unquoted token), keep it bare.
+    if (/^[a-zA-Z_$][a-zA-Z0-9_$\-.]*$/.test(val)) return val;
+    return `"${val}"`;
+}
+
+/**
+ * Detect whether the last member of a type is an inline brace object, and if so
+ * return the prefix type string and the inline object for expanded printing.
+ * Returns null if the type doesn't end with an inline object.
+ */
+export function extractTrailingInlineObject(type: ContractTypeNode): {
+    prefix: string | null;
+    inlineObj: InlineObjectTypeNode;
+} | null {
+    if (type.kind === 'inlineObject') {
+        return { prefix: null, inlineObj: type };
+    }
+    if (type.kind === 'intersection') {
+        const last = type.members[type.members.length - 1];
+        if (last?.kind === 'inlineObject') {
+            const prefixStr = type.members.slice(0, -1).map(printType).join(' & ');
+            return { prefix: prefixStr, inlineObj: last };
+        }
+    }
+    return null;
+}