frida 16.2.0 → 16.2.2

package/releng/meson/mesonbuild/cargo/interpreter.py

@@ -0,0 +1,733 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright © 2022-2024 Intel Corporation
+
+"""Interpreter for converting Cargo Toml definitions to Meson AST
+
+There are some notable limits here. We don't even try to convert something with
+a build.rs: there's so few limits on what Cargo allows a build.rs (basically
+none), and no good way for us to convert them. In that case, an actual meson
+port will be required.
+"""
+
+from __future__ import annotations
+import dataclasses
+import glob
+import importlib
+import itertools
+import json
+import os
+import shutil
+import collections
+import typing as T
+
+from . import builder
+from . import version
+from ..mesonlib import MesonException, Popen_safe, OptionKey
+from .. import coredata
+
+if T.TYPE_CHECKING:
+    from types import ModuleType
+
+    from . import manifest
+    from .. import mparser
+    from ..environment import Environment
+    from ..coredata import KeyedOptionDictType
+
+# tomllib is present in python 3.11, before that it is a pypi module called tomli,
+# we try to import tomllib, then tomli,
+# TODO: add a fallback to toml2json?
+tomllib: T.Optional[ModuleType] = None
+toml2json: T.Optional[str] = None
+for t in ['tomllib', 'tomli']:
+    try:
+        tomllib = importlib.import_module(t)
+        break
+    except ImportError:
+        pass
+else:
+    # TODO: it would be better to use an Executable here, which could be looked
+    # up in the cross file or provided by a wrap. However, that will have to be
+    # passed in externally, since we don't have (and I don't think we should),
+    # have access to the `Environment` for that in this module.
+    toml2json = shutil.which('toml2json')
+
+
+def load_toml(filename: str) -> T.Dict[object, object]:
+    if tomllib:
+        with open(filename, 'rb') as f:
+            raw = tomllib.load(f)
+    else:
+        if toml2json is None:
+            raise MesonException('Could not find an implementation of tomllib, nor toml2json')
+
+        p, out, err = Popen_safe([toml2json, filename])
+        if p.returncode != 0:
+            raise MesonException('toml2json failed to decode output\n', err)
+
+        raw = json.loads(out)
+
+    if not isinstance(raw, dict):
+        raise MesonException("Cargo.toml isn't a dictionary? How did that happen?")
+
+    return raw
+
+
+def fixup_meson_varname(name: str) -> str:
+    """Fixup a meson variable name
+
+    :param name: The name to fix
+    :return: the fixed name
+    """
+    return name.replace('-', '_')
+
+
+# Pylance can figure out that these do not, in fact, overlap, but mypy can't
+@T.overload
+def _fixup_raw_mappings(d: manifest.BuildTarget) -> manifest.FixedBuildTarget: ...  # type: ignore
+
+@T.overload
+def _fixup_raw_mappings(d: manifest.LibTarget) -> manifest.FixedLibTarget: ...  # type: ignore
+
+@T.overload
+def _fixup_raw_mappings(d: manifest.Dependency) -> manifest.FixedDependency: ...
+
+def _fixup_raw_mappings(d: T.Union[manifest.BuildTarget, manifest.LibTarget, manifest.Dependency]
+                        ) -> T.Union[manifest.FixedBuildTarget, manifest.FixedLibTarget,
+                                     manifest.FixedDependency]:
+    """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 Dependndency 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 'version' in raw:
+        assert isinstance(raw['version'], str), 'for mypy'
+        raw['version'] = version.convert(raw['version'])
+    return T.cast('T.Union[manifest.FixedBuildTarget, manifest.FixedLibTarget, manifest.FixedDependency]', raw)
+
+
+@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.Dict[str, str]] = dataclasses.field(default_factory=dict)
+    default_run: T.Optional[str] = None
+    autobins: bool = True
+    autoexamples: bool = True
+    autotests: bool = True
+    autobenches: bool = True
+
+
+@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_to_api(v[2:].strip()))
+            elif v.startswith('='):
+                api.add(_version_to_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: manifest.DependencyV) -> Dependency:
+        """Create a dependency from a raw cargo dictionary"""
+        if isinstance(raw, str):
+            return cls(name, version.convert(raw))
+        return cls(name, **_fixup_raw_mappings(raw))
+
+
+@dataclasses.dataclass
+class BuildTarget:
+
+    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
+
+
+@dataclasses.dataclass
+class Library(BuildTarget):
+
+    """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
+
+
+@dataclasses.dataclass
+class Binary(BuildTarget):
+
+    """Representation of a Cargo Bin Entry."""
+
+    doc: bool = True
+
+
+@dataclasses.dataclass
+class Test(BuildTarget):
+
+    """Representation of a Cargo Test Entry."""
+
+    bench: bool = True
+
+
+@dataclasses.dataclass
+class Benchmark(BuildTarget):
+
+    """Representation of a Cargo Benchmark Entry."""
+
+    test: bool = True
+
+
+@dataclasses.dataclass
+class Example(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 subdir: the subdirectory that this cargo project is in
+    :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]
+    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]]
+    subdir: str
+    path: str = ''
+
+    def __post_init__(self) -> None:
+        self.features.setdefault('default', [])
+
+
+def _convert_manifest(raw_manifest: manifest.Manifest, subdir: str, path: str = '') -> Manifest:
+    # This cast is a bit of a hack to deal with proc-macro
+    lib = _fixup_raw_mappings(raw_manifest.get('lib', {}))
+
+    # We need to set the name field if it's not set manually,
+    # including if other fields are set in the lib section
+    lib.setdefault('name', raw_manifest['package']['name'])
+
+    pkg = T.cast('manifest.FixedPackage',
+                 {fixup_meson_varname(k): v for k, v in raw_manifest['package'].items()})
+
+    return Manifest(
+        Package(**pkg),
+        {k: Dependency.from_raw(k, v) for k, v in raw_manifest.get('dependencies', {}).items()},
+        {k: Dependency.from_raw(k, v) for k, v in raw_manifest.get('dev-dependencies', {}).items()},
+        {k: Dependency.from_raw(k, v) for k, v in raw_manifest.get('build-dependencies', {}).items()},
+        Library(**lib),
+        [Binary(**_fixup_raw_mappings(b)) for b in raw_manifest.get('bin', {})],
+        [Test(**_fixup_raw_mappings(b)) for b in raw_manifest.get('test', {})],
+        [Benchmark(**_fixup_raw_mappings(b)) for b in raw_manifest.get('bench', {})],
+        [Example(**_fixup_raw_mappings(b)) for b in raw_manifest.get('example', {})],
+        raw_manifest.get('features', {}),
+        {k: {k2: Dependency.from_raw(k2, v2) for k2, v2 in v.get('dependencies', {}).items()}
+         for k, v in raw_manifest.get('target', {}).items()},
+        subdir,
+        path,
+    )
+
+
+def _load_manifests(subdir: str) -> T.Dict[str, Manifest]:
+    filename = os.path.join(subdir, 'Cargo.toml')
+    raw = load_toml(filename)
+
+    manifests: T.Dict[str, Manifest] = {}
+
+    raw_manifest: T.Union[manifest.Manifest, manifest.VirtualManifest]
+    if 'package' in raw:
+        raw_manifest = T.cast('manifest.Manifest', raw)
+        manifest_ = _convert_manifest(raw_manifest, subdir)
+        manifests[manifest_.package.name] = manifest_
+    else:
+        raw_manifest = T.cast('manifest.VirtualManifest', raw)
+
+    if 'workspace' in raw_manifest:
+        # XXX: need to verify that python glob and cargo globbing are the
+        # same and probably write  a glob implementation. Blarg
+
+        # We need to chdir here to make the glob work correctly
+        pwd = os.getcwd()
+        os.chdir(subdir)
+        members: T.Iterable[str]
+        try:
+            members = itertools.chain.from_iterable(
+                glob.glob(m) for m in raw_manifest['workspace']['members'])
+        finally:
+            os.chdir(pwd)
+        if 'exclude' in raw_manifest['workspace']:
+            members = (x for x in members if x not in raw_manifest['workspace']['exclude'])
+
+        for m in members:
+            filename = os.path.join(subdir, m, 'Cargo.toml')
+            raw = load_toml(filename)
+
+            raw_manifest = T.cast('manifest.Manifest', raw)
+            man = _convert_manifest(raw_manifest, subdir, m)
+            manifests[man.package.name] = man
+
+    return manifests
+
+
+def _version_to_api(version: str) -> str:
+    # x.y.z -> x
+    # 0.x.y -> 0.x
+    # 0.0.x -> 0
+    vers = version.split('.')
+    if int(vers[0]) != 0:
+        return vers[0]
+    elif len(vers) >= 2 and int(vers[1]) != 0:
+        return f'0.{vers[1]}'
+    return '0'
+
+
+def _dependency_name(package_name: str, api: str) -> str:
+    basename = package_name[:-3] if package_name.endswith('-rs') else package_name
+    return f'{basename}-{api}-rs'
+
+
+def _dependency_varname(package_name: str) -> str:
+    return f'{fixup_meson_varname(package_name)}_dep'
+
+
+_OPTION_NAME_PREFIX = 'feature-'
+
+
+def _option_name(feature: str) -> str:
+    # Add a prefix to avoid collision with Meson reserved options (e.g. "debug")
+    return _OPTION_NAME_PREFIX + feature
+
+
+def _options_varname(depname: str) -> str:
+    return f'{fixup_meson_varname(depname)}_options'
+
+
+def _extra_args_varname() -> str:
+    return 'extra_args'
+
+
+def _extra_deps_varname() -> str:
+    return 'extra_deps'
+
+
+def _create_project(cargo: Manifest, build: builder.Builder) -> T.List[mparser.BaseNode]:
+    """Create a function call
+
+    :param cargo: The Manifest to generate from
+    :param build: The AST builder
+    :return: a list nodes
+    """
+    args: T.List[mparser.BaseNode] = []
+    args.extend([
+        build.string(cargo.package.name),
+        build.string('rust'),
+    ])
+    kwargs: T.Dict[str, mparser.BaseNode] = {
+        'version': build.string(cargo.package.version),
+        # Always assume that the generated meson is using the latest features
+        # This will warn when when we generate deprecated code, which is helpful
+        # for the upkeep of the module
+        'meson_version': build.string(f'>= {coredata.stable_version}'),
+        'default_options': build.array([build.string(f'rust_std={cargo.package.edition}')]),
+    }
+    if cargo.package.license:
+        kwargs['license'] = build.string(cargo.package.license)
+    elif cargo.package.license_file:
+        kwargs['license_files'] = build.string(cargo.package.license_file)
+
+    return [build.function('project', args, kwargs)]
+
+
+def _process_feature(cargo: Manifest, feature: str) -> T.Tuple[T.Set[str], T.Dict[str, T.Set[str]], T.Set[str]]:
+    # Set of features that must also be enabled if this feature is enabled.
+    features: T.Set[str] = set()
+    # Map dependency name to a set of features that must also be enabled on that
+    # dependency if this feature is enabled.
+    dep_features: T.Dict[str, T.Set[str]] = collections.defaultdict(set)
+    # Set of dependencies that are required if this feature is enabled.
+    required_deps: T.Set[str] = set()
+    # Set of features that must be processed recursively.
+    to_process: T.Set[str] = {feature}
+    while to_process:
+        f = to_process.pop()
+        if '/' in f:
+            dep, dep_f = f.split('/', 1)
+            if dep[-1] == '?':
+                dep = dep[:-1]
+            else:
+                required_deps.add(dep)
+            dep_features[dep].add(dep_f)
+        elif f.startswith('dep:'):
+            required_deps.add(f[4:])
+        elif f not in features:
+            features.add(f)
+            to_process.update(cargo.features.get(f, []))
+            # A feature can also be a dependency
+            if f in cargo.dependencies:
+                required_deps.add(f)
+    return features, dep_features, required_deps
+
+
+def _create_features(cargo: Manifest, build: builder.Builder) -> T.List[mparser.BaseNode]:
+    # https://doc.rust-lang.org/cargo/reference/features.html#the-features-section
+
+    # Declare a dict that map enabled features to true. One for current project
+    # and one per dependency.
+    ast: T.List[mparser.BaseNode] = []
+    ast.append(build.assign(build.dict({}), 'features'))
+    for depname in cargo.dependencies:
+        ast.append(build.assign(build.dict({}), _options_varname(depname)))
+
+    # Declare a dict that map required dependencies to true
+    ast.append(build.assign(build.dict({}), 'required_deps'))
+
+    for feature in cargo.features:
+        # if get_option(feature)
+        #   required_deps += {'dep': true, ...}
+        #   features += {'foo': true, ...}
+        #   xxx_options += {'feature-foo': true, ...}
+        #   ...
+        # endif
+        features, dep_features, required_deps = _process_feature(cargo, feature)
+        lines: T.List[mparser.BaseNode] = [
+            build.plusassign(
+                build.dict({build.string(d): build.bool(True) for d in required_deps}),
+                'required_deps'),
+            build.plusassign(
+                build.dict({build.string(f): build.bool(True) for f in features}),
+                'features'),
+        ]
+        for depname, enabled_features in dep_features.items():
+            lines.append(build.plusassign(
+                build.dict({build.string(_option_name(f)): build.bool(True) for f in enabled_features}),
+                _options_varname(depname)))
+
+        ast.append(build.if_(build.function('get_option', [build.string(_option_name(feature))]), build.block(lines)))
+
+    ast.append(build.function('message', [
+        build.string('Enabled features:'),
+        build.method('keys', build.identifier('features'))],
+    ))
+
+    return ast
+
+
+def _create_dependencies(cargo: Manifest, build: builder.Builder) -> T.List[mparser.BaseNode]:
+    ast: T.List[mparser.BaseNode] = []
+    for name, dep in cargo.dependencies.items():
+        # xxx_options += {'feature-default': true, ...}
+        extra_options: T.Dict[mparser.BaseNode, mparser.BaseNode] = {
+            build.string(_option_name('default')): build.bool(dep.default_features),
+        }
+        for f in dep.features:
+            extra_options[build.string(_option_name(f))] = build.bool(True)
+        ast.append(build.plusassign(build.dict(extra_options), _options_varname(name)))
+
+        kw = {
+            'version': build.array([build.string(s) for s in dep.version]),
+            'default_options': build.identifier(_options_varname(name)),
+        }
+        if dep.optional:
+            kw['required'] = build.method('get', build.identifier('required_deps'), [
+                build.string(name), build.bool(False)
+            ])
+
+        # Lookup for this dependency with the features we want in default_options kwarg.
+        #
+        # However, this subproject could have been previously configured with a
+        # different set of features. Cargo collects the set of features globally
+        # but Meson can only use features enabled by the first call that triggered
+        # the configuration of that subproject.
+        #
+        # Verify all features that we need are actually enabled for that dependency,
+        # otherwise abort with an error message. The user has to set the corresponding
+        # option manually with -Dxxx-rs:feature-yyy=true, or the main project can do
+        # that in its project(..., default_options: ['xxx-rs:feature-yyy=true']).
+        ast.extend([
+            # xxx_dep = dependency('xxx', version : ..., default_options : xxx_options)
+            build.assign(
+                build.function(
+                    'dependency',
+                    [build.string(_dependency_name(dep.package, dep.api))],
+                    kw,
+                ),
+                _dependency_varname(dep.package),
+            ),
+            # if xxx_dep.found()
+            build.if_(build.method('found', build.identifier(_dependency_varname(dep.package))), build.block([
+                # actual_features = xxx_dep.get_variable('features', default_value : '').split(',')
+                build.assign(
+                    build.method(
+                        'split',
+                        build.method(
+                            'get_variable',
+                            build.identifier(_dependency_varname(dep.package)),
+                            [build.string('features')],
+                            {'default_value': build.string('')}
+                        ),
+                        [build.string(',')],
+                    ),
+                    'actual_features'
+                ),
+                # needed_features = []
+                # foreach f, _ : xxx_options
+                #   needed_features += f.substring(8)
+                # endforeach
+                build.assign(build.array([]), 'needed_features'),
+                build.foreach(['f', 'enabled'], build.identifier(_options_varname(name)), build.block([
+                    build.if_(build.identifier('enabled'), build.block([
+                        build.plusassign(
+                            build.method('substring', build.identifier('f'), [build.number(len(_OPTION_NAME_PREFIX))]),
+                            'needed_features'),
+                    ])),
+                ])),
+                # foreach f : needed_features
+                #   if f not in actual_features
+                #     error()
+                #   endif
+                # endforeach
+                build.foreach(['f'], build.identifier('needed_features'), build.block([
+                    build.if_(build.not_in(build.identifier('f'), build.identifier('actual_features')), build.block([
+                        build.function('error', [
+                            build.string('Dependency'),
+                            build.string(_dependency_name(dep.package, dep.api)),
+                            build.string('previously configured with features'),
+                            build.identifier('actual_features'),
+                            build.string('but need'),
+                            build.identifier('needed_features'),
+                        ])
+                    ]))
+                ])),
+            ])),
+        ])
+    return ast
+
+
+def _create_meson_subdir(cargo: Manifest, build: builder.Builder) -> T.List[mparser.BaseNode]:
+    # Allow Cargo subprojects to add extra Rust args in meson/meson.build file.
+    # This is used to replace build.rs logic.
+
+    # extra_args = []
+    # extra_deps = []
+    # fs = import('fs')
+    # if fs.is_dir('meson')
+    #  subdir('meson')
+    # endif
+    return [
+        build.assign(build.array([]), _extra_args_varname()),
+        build.assign(build.array([]), _extra_deps_varname()),
+        build.assign(build.function('import', [build.string('fs')]), 'fs'),
+        build.if_(build.method('is_dir', build.identifier('fs'), [build.string('meson')]),
+                  build.block([build.function('subdir', [build.string('meson')])]))
+    ]
+
+
+def _create_lib(cargo: Manifest, build: builder.Builder, crate_type: manifest.CRATE_TYPE) -> T.List[mparser.BaseNode]:
+    dependencies: T.List[mparser.BaseNode] = []
+    dependency_map: T.Dict[mparser.BaseNode, mparser.BaseNode] = {}
+    for name, dep in cargo.dependencies.items():
+        dependencies.append(build.identifier(_dependency_varname(dep.package)))
+        if name != dep.package:
+            dependency_map[build.string(fixup_meson_varname(dep.package))] = build.string(name)
+
+    rust_args: T.List[mparser.BaseNode] = [
+        build.identifier('features_args'),
+        build.identifier(_extra_args_varname())
+    ]
+
+    dependencies.append(build.identifier(_extra_deps_varname()))
+
+    posargs: T.List[mparser.BaseNode] = [
+        build.string(fixup_meson_varname(cargo.package.name)),
+        build.string(cargo.lib.path),
+    ]
+
+    kwargs: T.Dict[str, mparser.BaseNode] = {
+        'dependencies': build.array(dependencies),
+        'rust_dependency_map': build.dict(dependency_map),
+        'rust_args': build.array(rust_args),
+    }
+
+    lib: mparser.BaseNode
+    if cargo.lib.proc_macro or crate_type == 'proc-macro':
+        lib = build.method('proc_macro', build.identifier('rust'), posargs, kwargs)
+    else:
+        if crate_type in {'lib', 'rlib', 'staticlib'}:
+            target_type = 'static_library'
+        elif crate_type in {'dylib', 'cdylib'}:
+            target_type = 'shared_library'
+        else:
+            raise MesonException(f'Unsupported crate type {crate_type}')
+        if crate_type in {'staticlib', 'cdylib'}:
+            kwargs['rust_abi'] = build.string('c')
+        lib = build.function(target_type, posargs, kwargs)
+
+    # features_args = []
+    # foreach f, _ : features
+    #   features_args += ['--cfg', 'feature="' + f + '"']
+    # endforeach
+    # lib = xxx_library()
+    # dep = declare_dependency()
+    # meson.override_dependency()
+    return [
+        build.assign(build.array([]), 'features_args'),
+        build.foreach(['f', '_'], build.identifier('features'), build.block([
+            build.plusassign(
+                build.array([
+                    build.string('--cfg'),
+                    build.plus(build.string('feature="'), build.plus(build.identifier('f'), build.string('"'))),
+                ]),
+                'features_args')
+            ])
+        ),
+        build.assign(lib, 'lib'),
+        build.assign(
+            build.function(
+                'declare_dependency',
+                kw={
+                    'link_with': build.identifier('lib'),
+                    'variables': build.dict({
+                        build.string('features'): build.method('join', build.string(','), [build.method('keys', build.identifier('features'))]),
+                    })
+                },
+            ),
+            'dep'
+        ),
+        build.method(
+            'override_dependency',
+            build.identifier('meson'),
+            [
+                build.string(_dependency_name(cargo.package.name, _version_to_api(cargo.package.version))),
+                build.identifier('dep'),
+            ],
+        ),
+    ]
+
+
+def interpret(subp_name: str, subdir: str, env: Environment) -> T.Tuple[mparser.CodeBlockNode, KeyedOptionDictType]:
+    # subp_name should be in the form "foo-0.1-rs"
+    package_name = subp_name.rsplit('-', 2)[0]
+    manifests = _load_manifests(os.path.join(env.source_dir, subdir))
+    cargo = manifests.get(package_name)
+    if not cargo:
+        raise MesonException(f'Cargo package {package_name!r} not found in {subdir}')
+
+    filename = os.path.join(cargo.subdir, cargo.path, 'Cargo.toml')
+    build = builder.Builder(filename)
+
+    # Generate project options
+    options: T.Dict[OptionKey, coredata.UserOption] = {}
+    for feature in cargo.features:
+        key = OptionKey(_option_name(feature), subproject=subp_name)
+        enabled = feature == 'default'
+        options[key] = coredata.UserBooleanOption(key.name, f'Cargo {feature} feature', enabled)
+
+    ast = _create_project(cargo, build)
+    ast += [build.assign(build.function('import', [build.string('rust')]), 'rust')]
+    ast += _create_features(cargo, build)
+    ast += _create_dependencies(cargo, build)
+    ast += _create_meson_subdir(cargo, build)
+
+    # Libs are always auto-discovered and there's no other way to handle them,
+    # which is unfortunate for reproducability
+    if os.path.exists(os.path.join(env.source_dir, cargo.subdir, cargo.path, cargo.lib.path)):
+        for crate_type in cargo.lib.crate_type:
+            ast.extend(_create_lib(cargo, build, crate_type))
+
+    return build.block(ast), options