jsonObjectList(details.trace.sequence.asIterable()) { trace ->
                    writePropertyTrace(trace)
                }
            }
            comma()
            property(keyFor(kind)) {
                writeStructuredMessage(details.message)
            }
            details.documentationSection?.let {
                comma()
                property("documentationLink", documentationLinkFor(it))

Type FallbackDialect::parseType(DialectAsmParser &parser) const {
  StringRef keyword;
  if (parser.parseKeyword(&keyword)) return Type();

  if (keyword == "tf_tensor") return TFTensorType::get(getContext());
  if (keyword == "tf_allocator") return TFAllocatorType::get(getContext());

  parser.emitError(parser.getNameLoc(), "unknown type: ") << keyword;
  return Type();
}

/// Print a type registered to this dialect.

  llvm::StringRef keyword;
  if (parser.parseKeyword(&keyword)) return mlir::Type();

  if (keyword == "future") return FutureType::get(getContext());
  if (keyword == "promise") return PromiseType::get(getContext());
  if (keyword == "async_handle") return AsyncHandleType::get(getContext());

  parser.emitError(parser.getNameLoc(), "unknown type: ") << keyword;
  return mlir::Type();
}

        override fun renderKeyword(
            analysisSession: KaSession,
            keyword: KtKeywordToken,
            owner: KaAnnotated,
            keywordsRenderer: KaKeywordsRenderer,
            printer: PrettyPrinter,
        ) {
            if (keywordsRenderer.keywordFilter.filter(analysisSession, keyword, owner)) {
                printer.append(keyword.value)
            }
        }
    }

        symbol: KaCallableSymbol,
        keyword: KtKeywordToken?,
        declarationRenderer: KaDeclarationRenderer,
        printer: PrettyPrinter,
    )

    public object FOR_SOURCE : KaCallableSignatureRenderer {
        override fun renderCallableSignature(
            analysisSession: KaSession,
            symbol: KaCallableSymbol,
            keyword: KtKeywordToken?,

mlir::Type TensorflowMlrtDialect::parseType(
    mlir::DialectAsmParser &parser) const {
  llvm::StringRef keyword;
  if (parser.parseKeyword(&keyword)) return mlir::Type();

  if (keyword == "tensor") return TFTensorType::get(getContext());

  parser.emitError(parser.getNameLoc(), "unknown type: ") << keyword;
  return mlir::Type();
}

// Print a type registered to this dialect.

    public val keywordFilter: KaRendererKeywordFilter,
) {

    public fun renderKeyword(analysisSession: KaSession, keyword: KtKeywordToken, owner: KaAnnotated, printer: PrettyPrinter) {
        keywordRenderer.renderKeyword(analysisSession, keyword, owner, this, printer)
    }

    public fun renderKeywords(analysisSession: KaSession, keywords: List<KtKeywordToken>, owner: KaAnnotated, printer: PrettyPrinter) {

    symbol: S,
    declarationRenderer: KaDeclarationRenderer,
    printer: PrettyPrinter,
    keyword: KtKeywordToken,
): Unit where S : KaAnnotated, S : KaDeclarationSymbol = printer {
    renderAnnotationsModifiersAndContextReceivers(analysisSession, symbol, declarationRenderer, printer, listOf(keyword))
}

public fun <S> renderAnnotationsModifiersAndContextReceivers(
    analysisSession: KaSession,
    symbol: S,

            printer: PrettyPrinter,
        ) {
            printer {
                declarationRenderer.callableSignatureRenderer
                    .renderCallableSignature(analysisSession, symbol, keyword = null, declarationRenderer, printer)
            }
        }
    }
}

            printer {
                " = ".separated(
                    {
                        declarationRenderer.callableSignatureRenderer
                            .renderCallableSignature(analysisSession, symbol, keyword = null, declarationRenderer, printer)
                    },
                    { declarationRenderer.parameterDefaultValueRenderer.renderDefaultValue(analysisSession, symbol, printer) },
                )
            }