use std::collections::{BTreeMap, BTreeSet};
use std::fmt::Write;
use serde::{Deserialize, Serialize};
use thiserror::Error;
use super::{ItemReference, ParameterKind, RGenericReference, Signature, SignatureExpression};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PythonIdentityKind {
Module,
Function,
Method,
Constructor,
Class,
Property,
Constant,
Field,
TypeAlias,
}
impl PythonIdentityKind {
fn tag(self) -> &'static str {
match self {
Self::Module => "module",
Self::Function => "function",
Self::Method => "method",
Self::Constructor => "constructor",
Self::Class => "class",
Self::Property => "property",
Self::Constant => "constant",
Self::Field => "field",
Self::TypeAlias => "type-alias",
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
pub struct SemanticIdentity(String);
impl SemanticIdentity {
pub fn cpp(name: &str, kind: &str) -> Result<Self, IdentityError> {
nonempty("canonical-name", name)?;
nonempty("cpp-kind", kind)?;
Ok(Self(format!("sid1:cpp:{}:{}", atom(kind), atom(name))))
}
pub fn cpp_overload(name: &str, dispatch: &SignatureExpression) -> Result<Self, IdentityError> {
let mut key = format!("{}:overload:", Self::cpp(name, "callable")?.0);
expression(&mut key, dispatch)?;
Ok(Self(key))
}
pub fn rust(name: &str, kind: &str) -> Result<Self, IdentityError> {
nonempty("canonical-name", name)?;
nonempty("rust-kind", kind)?;
Ok(Self(format!("sid1:rust:{}:{}", atom(kind), atom(name))))
}
pub fn rust_member(
owner: &str,
context: &str,
name: &str,
kind: &str,
) -> Result<Self, IdentityError> {
nonempty("owner", owner)?;
nonempty("member-name", name)?;
nonempty("rust-kind", kind)?;
Ok(Self(format!(
"sid1:rust:{}:{}:{}:{}",
atom(kind),
atom(owner),
atom(context),
atom(name)
)))
}
pub fn julia(name: &str, kind: JuliaIdentityKind) -> Result<Self, IdentityError> {
nonempty("canonical-name", name)?;
Ok(Self(format!("sid1:julia:{}:{}", kind.tag(), atom(name))))
}
pub fn julia_method(name: &str, dispatch: &SignatureExpression) -> Result<Self, IdentityError> {
nonempty("canonical-name", name)?;
let mut key = format!("sid1:julia:method:{}:", atom(name));
expression(&mut key, dispatch)?;
Ok(Self(key))
}
pub fn python(name: &str, kind: PythonIdentityKind) -> Result<Self, IdentityError> {
nonempty("canonical-name", name)?;
Ok(Self(format!("sid1:python:{}:{}", kind.tag(), atom(name))))
}
pub fn python_overload(
name: &str,
kind: PythonIdentityKind,
signature: &Signature,
) -> Result<Self, IdentityError> {
if !matches!(
kind,
PythonIdentityKind::Function
| PythonIdentityKind::Method
| PythonIdentityKind::Constructor
) {
return Err(invalid(
"python-kind",
"overloads require a callable family",
));
}
let family = Self::python(name, kind)?;
let Signature::Callable {
parameters,
returns,
} = signature
else {
return Err(invalid(
"signature",
"overloads require a callable signature",
));
};
let mut key = format!("{}:overload:call(", family.0);
for parameter in parameters {
nonempty("parameter-name", ¶meter.name)?;
key.push_str("parameter(");
key.push_str(&atom(¶meter.name));
key.push(',');
match ¶meter.kind {
ParameterKind::PositionalOnly => key.push_str("positional-only"),
ParameterKind::PositionalOrKeyword => key.push_str("positional-or-keyword"),
ParameterKind::KeywordOnly => key.push_str("keyword-only"),
ParameterKind::VariadicPositional => key.push_str("variadic-positional"),
ParameterKind::VariadicKeyword => key.push_str("variadic-keyword"),
ParameterKind::LanguageSpecific { language, name } => {
write!(key, "language-specific({},{})", atom(language), atom(name)).unwrap();
}
}
key.push(',');
expression_option(&mut key, parameter.annotation.as_ref())?;
key.push(',');
expression_option(&mut key, parameter.default.as_ref())?;
key.push_str(");");
}
key.push_str(")returns(");
expression_option(&mut key, returns.as_ref())?;
key.push(')');
Ok(Self(key))
}
pub fn r_function(name: &str) -> Result<Self, IdentityError> {
Self::r_named(name, "function")
}
pub fn r_package(name: &str) -> Result<Self, IdentityError> {
Self::r_named(name, "package")
}
pub fn r_constant(name: &str) -> Result<Self, IdentityError> {
Self::r_named(name, "constant")
}
pub fn r_deprecated_topic(name: &str) -> Result<Self, IdentityError> {
Self::r_named(name, "deprecated-topic")
}
pub fn r_dataset(name: &str) -> Result<Self, IdentityError> {
Self::r_named(name, "dataset")
}
pub fn r_s3_generic(name: &str) -> Result<Self, IdentityError> {
Self::r_named(name, "s3-generic")
}
pub fn r_s3_method(
name: &str,
generic: &RGenericReference,
class: &str,
) -> Result<Self, IdentityError> {
let mut identity = Self::r_named(name, "s3-method")?;
nonempty("dispatch-class", class)?;
let generic = match generic {
RGenericReference::Workspace { item } => {
nonempty("generic-package", &item.package)?;
nonempty("generic-item", &item.item)?;
format!("workspace({},{})", atom(&item.package), atom(&item.item))
}
RGenericReference::External { package, name } => {
nonempty("generic-package", package)?;
nonempty("generic-name", name)?;
format!("external({},{})", atom(package), atom(name))
}
};
write!(identity.0, ":{generic}:{}", atom(class)).unwrap();
Ok(identity)
}
fn r_named(name: &str, kind: &str) -> Result<Self, IdentityError> {
nonempty("canonical-name", name)?;
Ok(Self(format!("sid1:r:{kind}:{}", atom(name))))
}
pub fn item_id(&self) -> &str {
&self.0
}
pub fn in_package(&self, package: &str) -> Result<ItemReference, IdentityError> {
nonempty("package", package)?;
Ok(ItemReference {
package: package.into(),
item: self.0.clone(),
})
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum JuliaIdentityKind {
Module,
Function,
Type,
Field,
Constant,
Macro,
}
impl JuliaIdentityKind {
fn tag(self) -> &'static str {
match self {
Self::Module => "module",
Self::Function => "function",
Self::Type => "type",
Self::Field => "field",
Self::Constant => "constant",
Self::Macro => "macro",
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Error)]
#[serde(tag = "code", rename_all = "kebab-case", deny_unknown_fields)]
pub enum IdentityError {
#[error("invalid semantic identity field {field}: {reason}")]
InvalidIdentity {
field: String,
reason: String,
},
#[error("duplicate canonical item {item:?}")]
#[serde(rename = "duplicate-item-identity")]
DuplicateIdentity {
item: ItemReference,
},
#[error("conflicting item alias {package}::{alias}")]
#[serde(rename = "conflicting-item-alias")]
ConflictingAlias {
package: String,
alias: String,
candidates: BTreeSet<ItemReference>,
},
#[error("unknown canonical target for alias {alias}: {target:?}")]
UnknownAliasTarget {
alias: String,
target: ItemReference,
},
}
impl IdentityError {
pub fn code(&self) -> &'static str {
match self {
Self::InvalidIdentity { .. } => "invalid-identity",
Self::DuplicateIdentity { .. } => "duplicate-item-identity",
Self::ConflictingAlias { .. } => "conflicting-item-alias",
Self::UnknownAliasTarget { .. } => "unknown-alias-target",
}
}
}
#[derive(Debug, Clone)]
pub struct IdentityRegistry {
package: String,
items: BTreeSet<String>,
aliases: BTreeMap<String, BTreeSet<ItemReference>>,
}
impl IdentityRegistry {
pub fn new(package: &str) -> Result<Self, IdentityError> {
nonempty("package", package)?;
Ok(Self {
package: package.into(),
items: BTreeSet::new(),
aliases: BTreeMap::new(),
})
}
pub fn register(
&mut self,
identity: &SemanticIdentity,
) -> Result<ItemReference, IdentityError> {
let item = identity.in_package(&self.package)?;
if !self.items.insert(item.item.clone()) {
return Err(IdentityError::DuplicateIdentity { item });
}
Ok(item)
}
pub fn bind_alias(&mut self, alias: &str, target: &ItemReference) -> Result<(), IdentityError> {
nonempty("alias", alias)?;
if target.package != self.package || !self.items.contains(&target.item) {
return Err(IdentityError::UnknownAliasTarget {
alias: alias.into(),
target: target.clone(),
});
}
self.aliases
.entry(alias.into())
.or_default()
.insert(target.clone());
self.resolve_alias(alias).map(|_| ())
}
pub fn resolve_alias(&self, alias: &str) -> Result<Option<&ItemReference>, IdentityError> {
let Some(candidates) = self.aliases.get(alias) else {
return Ok(None);
};
if candidates.len() > 1 {
return Err(IdentityError::ConflictingAlias {
package: self.package.clone(),
alias: alias.into(),
candidates: candidates.clone(),
});
}
Ok(candidates.first())
}
pub fn len(&self) -> usize {
self.items.len()
}
pub fn is_empty(&self) -> bool {
self.items.is_empty()
}
}
fn invalid(field: &str, reason: &str) -> IdentityError {
IdentityError::InvalidIdentity {
field: field.into(),
reason: reason.into(),
}
}
fn nonempty(field: &str, value: &str) -> Result<(), IdentityError> {
if value.is_empty() || value.chars().all(char::is_whitespace) {
Err(invalid(field, "a nonempty semantic value is required"))
} else {
Ok(())
}
}
fn atom(value: &str) -> String {
let mut encoded = String::new();
for byte in value.bytes() {
if byte.is_ascii_alphanumeric() || matches!(byte, b'_' | b'.' | b'-') {
encoded.push(char::from(byte));
} else {
write!(encoded, "%{byte:02X}").unwrap();
}
}
encoded
}
fn expression_option(
key: &mut String,
value: Option<&SignatureExpression>,
) -> Result<(), IdentityError> {
if let Some(value) = value {
key.push_str("some(");
expression(key, value)?;
key.push(')');
} else {
key.push_str("none");
}
Ok(())
}
fn expression(key: &mut String, value: &SignatureExpression) -> Result<(), IdentityError> {
match value {
SignatureExpression::Name { name, .. } => {
write!(key, "name({})", atom(name)).unwrap();
}
SignatureExpression::Literal { text } => {
write!(key, "literal({})", atom(text)).unwrap();
}
SignatureExpression::Apply {
constructor,
arguments,
} => {
key.push_str("apply(");
expression(key, constructor)?;
key.push(';');
expressions(key, arguments)?;
key.push(')');
}
SignatureExpression::Sequence { items } => {
key.push_str("sequence(");
expressions(key, items)?;
key.push(')');
}
SignatureExpression::LanguageSpecific {
language,
name,
children,
source,
} => {
if children.is_empty() && source.is_some() {
return Err(invalid(
"signature-expression",
"opaque source-only syntax cannot establish overload identity",
));
}
write!(key, "language-specific({},{},", atom(language), atom(name)).unwrap();
expressions(key, children)?;
key.push(')');
}
}
Ok(())
}
fn expressions(key: &mut String, values: &[SignatureExpression]) -> Result<(), IdentityError> {
for value in values {
expression(key, value)?;
key.push(';');
}
Ok(())
}