cargo: move library autodetection to Manifest.from_raw

It makes sense to make the lib argument optional, so do the same for all
the others as well because optional arguments must all go together.

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

Author: bonzini

mesonbuild/cargo/interpreter.py

@@ -100,9 +100,7 @@ def interpret(self, subdir: str) -> mparser.CodeBlockNode:
         ast += self._create_dependencies(pkg, build)
         ast += self._create_meson_subdir(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(self.environment.source_dir, subdir, pkg.manifest.path, pkg.manifest.lib.path)):
+        if pkg.manifest.lib:
             for crate_type in pkg.manifest.lib.crate_type:
                 ast.extend(self._create_lib(pkg, build, crate_type))
 
@@ -139,11 +137,12 @@ def _dep_package(self, dep: Dependency) -> PackageState:
     def _load_manifest(self, subdir: str) -> Manifest:
         manifest_ = self.manifests.get(subdir)
         if not manifest_:
-            filename = os.path.join(self.environment.source_dir, subdir, 'Cargo.toml')
+            path = os.path.join(self.environment.source_dir, subdir)
+            filename = os.path.join(path, 'Cargo.toml')
             toml = load_toml(filename)
             if 'package' in toml:
                 raw_manifest = T.cast('raw.Manifest', toml)
-                manifest_ = Manifest.from_raw(raw_manifest)
+                manifest_ = Manifest.from_raw(raw_manifest, path)
                 self.manifests[subdir] = manifest_
             else:
                 raise MesonException(f'{subdir}/Cargo.toml does not have [package] section')

mesonbuild/cargo/manifest.py

@@ -341,17 +341,17 @@ class Manifest:
     """
 
     package: Package
-    dependencies: T.Dict[str, Dependency]
-    dev_dependencies: T.Dict[str, Dependency]
-    build_dependencies: T.Dict[str, Dependency]
+    dependencies: T.Dict[str, Dependency] = dataclasses.field(default_factory=dict)
+    dev_dependencies: T.Dict[str, Dependency] = dataclasses.field(default_factory=dict)
+    build_dependencies: T.Dict[str, Dependency] = dataclasses.field(default_factory=dict)
     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]]
+    lib: T.Optional[Library] = None
+    bin: T.List[Binary] = dataclasses.field(default_factory=list)
+    test: T.List[Test] = dataclasses.field(default_factory=list)
+    bench: T.List[Benchmark] = dataclasses.field(default_factory=list)
+    example: T.List[Example] = dataclasses.field(default_factory=list)
+    features: T.Dict[str, T.List[str]] = dataclasses.field(default_factory=dict)
+    target: T.Dict[str, T.Dict[str, Dependency]] = dataclasses.field(default_factory=dict)
 
     path: str = ''
 
@@ -361,12 +361,18 @@ def __post_init__(self) -> None:
 
     @classmethod
     def from_raw(cls, raw: raw.Manifest, path: str = '') -> Self:
+        # Libs are always auto-discovered and there's no other way to handle them,
+        # which is unfortunate for reproducability
+        pkg = Package.from_raw(raw['package'])
+        if pkg.autolib and 'lib' not in raw and \
+                os.path.exists(os.path.join(path, 'src/lib.rs')):
+            raw['lib'] = {}
         return cls(
-            package=Package.from_raw(raw['package']),
+            package=pkg,
             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']),
+            lib=Library.from_raw(raw['lib'], raw['package']['name']) if 'lib' in raw else None,
             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', {})],