use serde::{Deserialize, Serialize};
use super::{ItemReference, SignatureExpression, SourceEvidence};
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(
tag = "language",
content = "data",
rename_all = "kebab-case",
deny_unknown_fields
)]
pub enum ItemLanguageData {
Cpp(super::CppItemData),
Rust(RustItemData),
Julia(JuliaItemData),
Python(PythonItemData),
R(RItemData),
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ItemAlias {
pub qualified_name: String,
pub kind: ItemAliasKind,
pub sources: Vec<SourceEvidence>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum ItemAliasKind {
RustReexport,
JuliaImport,
JuliaAssignment,
PythonReexport,
PythonAssignment,
RAssignment,
RdAlias,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct RustItemData {
pub declaration: RustDeclarationKind,
pub public_path: String,
pub owner: Option<ItemReference>,
pub implementation: Option<String>,
pub implementations: Vec<RustImplementation>,
pub attributes: Vec<String>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum RustDeclarationKind {
Module,
Struct,
Enum,
Union,
Trait,
Variant,
Function,
Method,
Field,
Constant,
Static,
TypeAlias,
AssociatedType,
Macro,
Implementation,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct RustImplementation {
pub identity: String,
pub signature: SignatureExpression,
pub documentation_item: Option<ItemReference>,
pub source_location: Option<super::SourceLocation>,
pub trait_name: Option<String>,
pub trait_target: Option<ItemReference>,
pub members: Vec<ItemReference>,
pub is_synthetic: bool,
pub is_blanket: bool,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct PythonItemData {
pub visibility: PythonVisibility,
pub declaration: PythonDeclaration,
pub decorators: Vec<PythonDecorator>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum PythonVisibility {
Public,
Private,
Unknown,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "kebab-case", deny_unknown_fields)]
pub enum PythonDeclaration {
Module {
source: PythonModuleSource,
exports: PythonExports,
},
Callable {
binding: PythonCallableKind,
is_async: bool,
role: PythonCallableRole,
},
Class {
bases: Vec<SignatureExpression>,
constructor: PythonConstructor,
},
Property {
has_setter: bool,
has_deleter: bool,
},
Constant,
Field,
TypeAlias {
target: SignatureExpression,
},
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum PythonModuleSource {
Runtime,
Implementation,
StubOnly,
ImplementationAndStub,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "kebab-case", deny_unknown_fields)]
pub enum PythonExports {
Runtime {
names: Vec<String>,
},
Implicit,
Explicit {
names: Vec<String>,
sources: Vec<SourceEvidence>,
},
Dynamic {
expression: SignatureExpression,
sources: Vec<SourceEvidence>,
},
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum PythonCallableKind {
Function,
InstanceMethod,
StaticMethod,
ClassMethod,
Constructor,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "kebab-case", deny_unknown_fields)]
pub enum PythonCallableRole {
Family {
overloads: Vec<ItemReference>,
},
Overload {
family: ItemReference,
},
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "kebab-case", deny_unknown_fields)]
pub enum PythonConstructor {
Unspecified,
Explicit {
item: ItemReference,
},
Dataclass {
fields: Vec<ItemReference>,
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
fields_include_inherited: bool,
init: bool,
frozen: bool,
},
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct PythonDecorator {
pub expression: SignatureExpression,
pub semantics: PythonDecoratorSemantics,
pub sources: Vec<SourceEvidence>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum PythonDecoratorSemantics {
Overload,
Property,
PropertySetter,
PropertyDeleter,
StaticMethod,
ClassMethod,
Dataclass,
ContextManager,
Unknown,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct RItemData {
pub exported: bool,
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
pub internal: bool,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub help_topic: Option<RHelpTopic>,
pub declaration: RDeclaration,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct RHelpTopic {
pub name: String,
pub primary: ItemReference,
pub members: Vec<ItemReference>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "kebab-case", deny_unknown_fields)]
pub enum RDeclaration {
Constant,
DeprecatedTopic,
Dataset,
Function,
S3Generic {
dispatch_name: String,
dispatch_object: Option<SignatureExpression>,
methods: Vec<ItemReference>,
},
S3Method {
generic: RGenericReference,
class: String,
registration: Vec<SourceEvidence>,
},
Constructor {
classes: Vec<String>,
},
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "kebab-case", deny_unknown_fields)]
pub enum RGenericReference {
Workspace {
item: ItemReference,
},
External {
package: String,
name: String,
},
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct JuliaItemData {
pub defining_module: String,
pub visibility: JuliaVisibility,
pub declaration: JuliaDeclaration,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum JuliaVisibility {
Exported,
Public,
Private,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "kebab-case", deny_unknown_fields)]
pub enum JuliaDeclaration {
Module {
bare: bool,
},
Callable {
binding: JuliaCallableKind,
role: JuliaCallableRole,
external_owner: Option<String>,
},
Type {
flavor: JuliaTypeKind,
parameters: Vec<SignatureExpression>,
supertype: Option<SignatureExpression>,
constructors: Vec<ItemReference>,
},
Constant,
Field {
is_const: bool,
},
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum JuliaCallableKind {
Function,
Constructor,
Macro,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "kebab-case", deny_unknown_fields)]
pub enum JuliaCallableRole {
Family {
methods: Vec<ItemReference>,
},
Method {
family: ItemReference,
dispatch: SignatureExpression,
},
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "kebab-case", deny_unknown_fields)]
pub enum JuliaTypeKind {
Struct {
mutable: bool,
},
Abstract,
Primitive {
bits: Option<String>,
},
}