cargo: move dataclasses out of interpreter module

Extracted from a patch by Xavier Classens.

Signed-off-by: Paolo Bonzini <[email protected]>

Author: bonzini

mesonbuild/cargo/interpreter.py

@@ -19,346 +19,19 @@
 
 from . import builder, version, cfg
 from .toml import load_toml, TomlImplementationMissing
-from .manifest import fixup_meson_varname, CargoLock
+from .manifest import Manifest, CargoLock, fixup_meson_varname
 from ..mesonlib import MesonException, MachineChoice
 from .. import coredata, mlog
 from ..wrap.wrap import PackageDefinition
 
 if T.TYPE_CHECKING:
-    from typing_extensions import Protocol, Self
-
-    from . import manifest, raw
+    from . import raw
     from .. import mparser
+    from .manifest import Dependency, SystemDependency
     from ..environment import Environment
     from ..interpreterbase import SubProject
     from ..compilers.rust import RustCompiler
 
-    # Copied from typeshed. Blarg that they don't expose this
-    class DataclassInstance(Protocol):
-        __dataclass_fields__: T.ClassVar[dict[str, dataclasses.Field[T.Any]]]
-
-_R = T.TypeVar('_R', bound='raw._BaseBuildTarget')
-
-
-_EXTRA_KEYS_WARNING = (
-    "This may (unlikely) be an error in the cargo manifest, or may be a missing "
-    "implementation in Meson. If this issue can be reproduced with the latest "
-    "version of Meson, please help us by opening an issue at "
-    "https://github.com/mesonbuild/meson/issues. Please include the crate and "
-    "version that is generating this warning if possible."
-)
-
-
-def _fixup_raw_mappings(d: T.Mapping[str, T.Any], convert_version: bool = True) -> T.MutableMapping[str, T.Any]:
-    """Fixup raw cargo mappings to ones more suitable for python to consume.
-
-    This does the following:
-    * replaces any `-` with `_`, cargo likes the former, but python dicts make
-      keys with `-` in them awkward to work with
-    * Convert Dependency versions from the cargo format to something meson
-      understands
-
-    :param d: The mapping to fix
-    :return: the fixed string
-    """
-    raw = {fixup_meson_varname(k): v for k, v in d.items()}
-    if convert_version and 'version' in raw:
-        assert isinstance(raw['version'], str), 'for mypy'
-        raw['version'] = version.convert(raw['version'])
-    return raw
-
-
-def _handle_unknown_keys(data: T.MutableMapping[str, T.Any], cls: T.Union[DataclassInstance, T.Type[DataclassInstance]],
-                         msg: str) -> T.MutableMapping[str, T.Any]:
-    """Remove and warn on keys that are coming from cargo, but are unknown to
-    our representations.
-
-    This is intended to give users the possibility of things proceeding when a
-    new key is added to Cargo.toml that we don't yet handle, but to still warn
-    them that things might not work.
-
-    :param data: The raw data to look at
-    :param cls: The Dataclass derived type that will be created
-    :param msg: the header for the error message. Usually something like "In N structure".
-    :return: The original data structure, but with all unknown keys removed.
-    """
-    unexpected = set(data) - {x.name for x in dataclasses.fields(cls)}
-    if unexpected:
-        mlog.warning(msg, 'has unexpected keys', '"{}".'.format(', '.join(sorted(unexpected))),
-                     _EXTRA_KEYS_WARNING)
-        for k in unexpected:
-            del data[k]
-    return data
-
-
-@dataclasses.dataclass
-class Package:
-
-    """Representation of a Cargo Package entry, with defaults filled in."""
-
-    name: str
-    version: str
-    description: T.Optional[str] = None
-    resolver: T.Optional[str] = None
-    authors: T.List[str] = dataclasses.field(default_factory=list)
-    edition: manifest.EDITION = '2015'
-    rust_version: T.Optional[str] = None
-    documentation: T.Optional[str] = None
-    readme: T.Optional[str] = None
-    homepage: T.Optional[str] = None
-    repository: T.Optional[str] = None
-    license: T.Optional[str] = None
-    license_file: T.Optional[str] = None
-    keywords: T.List[str] = dataclasses.field(default_factory=list)
-    categories: T.List[str] = dataclasses.field(default_factory=list)
-    workspace: T.Optional[str] = None
-    build: T.Optional[str] = None
-    links: T.Optional[str] = None
-    exclude: T.List[str] = dataclasses.field(default_factory=list)
-    include: T.List[str] = dataclasses.field(default_factory=list)
-    publish: bool = True
-    metadata: T.Dict[str, T.Any] = dataclasses.field(default_factory=dict)
-    default_run: T.Optional[str] = None
-    autolib: bool = True
-    autobins: bool = True
-    autoexamples: bool = True
-    autotests: bool = True
-    autobenches: bool = True
-    api: str = dataclasses.field(init=False)
-
-    def __post_init__(self) -> None:
-        self.api = version.api(self.version)
-
-    @classmethod
-    def from_raw(cls, raw: raw.Package) -> Self:
-        pkg = _fixup_raw_mappings(raw, convert_version=False)
-        pkg = _handle_unknown_keys(pkg, cls, f'Package entry {pkg["name"]}')
-        return cls(**pkg)
-
-@dataclasses.dataclass
-class SystemDependency:
-
-    """ Representation of a Cargo system-deps entry
-        https://docs.rs/system-deps/latest/system_deps
-    """
-
-    name: str
-    version: T.List[str]
-    optional: bool = False
-    feature: T.Optional[str] = None
-    feature_overrides: T.Dict[str, T.Dict[str, str]] = dataclasses.field(default_factory=dict)
-
-    @classmethod
-    def from_raw(cls, name: str, raw: T.Any) -> SystemDependency:
-        if isinstance(raw, str):
-            return cls(name, SystemDependency.convert_version(raw))
-        name = raw.get('name', name)
-        version = SystemDependency.convert_version(raw.get('version'))
-        optional = raw.get('optional', False)
-        feature = raw.get('feature')
-        # Everything else are overrides when certain features are enabled.
-        feature_overrides = {k: v for k, v in raw.items() if k not in {'name', 'version', 'optional', 'feature'}}
-        return cls(name, version, optional, feature, feature_overrides)
-
-    @staticmethod
-    def convert_version(version: T.Optional[str]) -> T.List[str]:
-        vers = version.split(',') if version is not None else []
-        result: T.List[str] = []
-        for v in vers:
-            v = v.strip()
-            if v[0] not in '><=':
-                v = f'>={v}'
-            result.append(v)
-        return result
-
-    def enabled(self, features: T.Set[str]) -> bool:
-        return self.feature is None or self.feature in features
-
-@dataclasses.dataclass
-class Dependency:
-
-    """Representation of a Cargo Dependency Entry."""
-
-    name: dataclasses.InitVar[str]
-    version: T.List[str]
-    registry: T.Optional[str] = None
-    git: T.Optional[str] = None
-    branch: T.Optional[str] = None
-    rev: T.Optional[str] = None
-    path: T.Optional[str] = None
-    optional: bool = False
-    package: str = ''
-    default_features: bool = True
-    features: T.List[str] = dataclasses.field(default_factory=list)
-    api: str = dataclasses.field(init=False)
-
-    def __post_init__(self, name: str) -> None:
-        self.package = self.package or name
-        # Extract wanted API version from version constraints.
-        api = set()
-        for v in self.version:
-            if v.startswith(('>=', '==')):
-                api.add(version.api(v[2:].strip()))
-            elif v.startswith('='):
-                api.add(version.api(v[1:].strip()))
-        if not api:
-            self.api = '0'
-        elif len(api) == 1:
-            self.api = api.pop()
-        else:
-            raise MesonException(f'Cannot determine minimum API version from {self.version}.')
-
-    @classmethod
-    def from_raw(cls, name: str, raw: raw.DependencyV) -> Dependency:
-        """Create a dependency from a raw cargo dictionary"""
-        if isinstance(raw, str):
-            return cls(name, version.convert(raw))
-        fixed = _handle_unknown_keys(_fixup_raw_mappings(raw), cls, f'Dependency entry {name}')
-        return cls(name, **fixed)
-
-
-@dataclasses.dataclass
-class BuildTarget(T.Generic[_R]):
-
-    name: str
-    crate_type: T.List[manifest.CRATE_TYPE] = dataclasses.field(default_factory=lambda: ['lib'])
-    path: dataclasses.InitVar[T.Optional[str]] = None
-
-    # https://doc.rust-lang.org/cargo/reference/cargo-targets.html#the-test-field
-    # True for lib, bin, test
-    test: bool = True
-
-    # https://doc.rust-lang.org/cargo/reference/cargo-targets.html#the-doctest-field
-    # True for lib
-    doctest: bool = False
-
-    # https://doc.rust-lang.org/cargo/reference/cargo-targets.html#the-bench-field
-    # True for lib, bin, benchmark
-    bench: bool = True
-
-    # https://doc.rust-lang.org/cargo/reference/cargo-targets.html#the-doc-field
-    # True for libraries and binaries
-    doc: bool = False
-
-    harness: bool = True
-    edition: manifest.EDITION = '2015'
-    required_features: T.List[str] = dataclasses.field(default_factory=list)
-    plugin: bool = False
-
-    @classmethod
-    def from_raw(cls, raw: raw.BuildTarget) -> Self:
-        name = raw.get('name', '<anonymous>')
-        build = _handle_unknown_keys(_fixup_raw_mappings(raw), cls, f'Binary entry {name}')
-        return cls(**build)
-
-@dataclasses.dataclass
-class Library(BuildTarget['raw.LibTarget']):
-
-    """Representation of a Cargo Library Entry."""
-
-    doctest: bool = True
-    doc: bool = True
-    path: str = os.path.join('src', 'lib.rs')
-    proc_macro: bool = False
-    crate_type: T.List[manifest.CRATE_TYPE] = dataclasses.field(default_factory=lambda: ['lib'])
-    doc_scrape_examples: bool = True
-
-    @classmethod
-    def from_raw(cls, raw: raw.LibTarget, fallback_name: str) -> Self:  # type: ignore[override]
-        if 'name' not in raw:
-            raw['name'] = fallback_name
-        fixed = _fixup_raw_mappings(raw)
-
-        # We need to set the name field if it's not set manually, including if
-        # other fields are set in the lib section
-        fixed = _handle_unknown_keys(fixed, cls, f'Library entry {fixed["name"]}')
-
-        return cls(**fixed)
-
-
-@dataclasses.dataclass
-class Binary(BuildTarget['raw.BuildTarget']):
-
-    """Representation of a Cargo Bin Entry."""
-
-    doc: bool = True
-
-
-@dataclasses.dataclass
-class Test(BuildTarget['raw.BuildTarget']):
-
-    """Representation of a Cargo Test Entry."""
-
-    bench: bool = True
-
-
-@dataclasses.dataclass
-class Benchmark(BuildTarget['raw.BuildTarget']):
-
-    """Representation of a Cargo Benchmark Entry."""
-
-    test: bool = True
-
-
-@dataclasses.dataclass
-class Example(BuildTarget['raw.BuildTarget']):
-
-    """Representation of a Cargo Example Entry."""
-
-    crate_type: T.List[manifest.CRATE_TYPE] = dataclasses.field(default_factory=lambda: ['bin'])
-
-
-@dataclasses.dataclass
-class Manifest:
-
-    """Cargo Manifest definition.
-
-    Most of these values map up to the Cargo Manifest, but with default values
-    if not provided.
-
-    Cargo subprojects can contain what Meson wants to treat as multiple,
-    interdependent, subprojects.
-
-    :param path: the path within the cargo subproject.
-    """
-
-    package: Package
-    dependencies: T.Dict[str, Dependency]
-    dev_dependencies: T.Dict[str, Dependency]
-    build_dependencies: T.Dict[str, Dependency]
-    system_dependencies: T.Dict[str, SystemDependency] = dataclasses.field(init=False)
-    lib: Library
-    bin: T.List[Binary]
-    test: T.List[Test]
-    bench: T.List[Benchmark]
-    example: T.List[Example]
-    features: T.Dict[str, T.List[str]]
-    target: T.Dict[str, T.Dict[str, Dependency]]
-    path: str = ''
-
-    def __post_init__(self) -> None:
-        self.features.setdefault('default', [])
-        self.system_dependencies = {k: SystemDependency.from_raw(k, v) for k, v in self.package.metadata.get('system-deps', {}).items()}
-
-    @classmethod
-    def from_raw(cls, raw: raw.Manifest, path: str = '') -> Self:
-        return cls(
-            package=Package.from_raw(raw['package']),
-            dependencies={k: Dependency.from_raw(k, v) for k, v in raw.get('dependencies', {}).items()},
-            dev_dependencies={k: Dependency.from_raw(k, v) for k, v in raw.get('dev-dependencies', {}).items()},
-            build_dependencies={k: Dependency.from_raw(k, v) for k, v in raw.get('build-dependencies', {}).items()},
-            lib=Library.from_raw(raw.get('lib', {}), raw['package']['name']),
-            bin=[Binary.from_raw(b) for b in raw.get('bin', {})],
-            test=[Test.from_raw(b) for b in raw.get('test', {})],
-            bench=[Benchmark.from_raw(b) for b in raw.get('bench', {})],
-            example=[Example.from_raw(b) for b in raw.get('example', {})],
-            features=raw.get('features', {}),
-            target={k: {k2: Dependency.from_raw(k2, v2) for k2, v2 in v.get('dependencies', {}).items()}
-                    for k, v in raw.get('target', {}).items()},
-            path=path,
-        )
-
-
 def _dependency_name(package_name: str, api: str, suffix: str = '-rs') -> str:
     basename = package_name[:-len(suffix)] if package_name.endswith(suffix) else package_name
     return f'{basename}-{api}{suffix}'
@@ -693,7 +366,7 @@ def _create_meson_subdir(self, build: builder.Builder) -> T.List[mparser.BaseNod
                       build.block([build.function('subdir', [build.string('meson')])]))
         ]
 
-    def _create_lib(self, pkg: PackageState, build: builder.Builder, crate_type: manifest.CRATE_TYPE) -> T.List[mparser.BaseNode]:
+    def _create_lib(self, pkg: PackageState, build: builder.Builder, crate_type: raw.CRATE_TYPE) -> T.List[mparser.BaseNode]:
         dependencies: T.List[mparser.BaseNode] = []
         dependency_map: T.Dict[mparser.BaseNode, mparser.BaseNode] = {}
         for name in pkg.required_deps: