[mp-alt] Add initial simple validation + errors (#21755)

## Description 

This PR adds a manifest error type and support for codespan reporting
via `serde_spanned`. It also adds the first two simple validations for
package name and editions.

## Test plan 

Updated existing tests.

---

## Release notes

Check each box that your changes affect. If none of the boxes relate to
your changes, release notes aren't required.

For each box you select, include information after the relevant heading
that describes the impact of your changes that a user might notice and
any actions they must take to implement updates.

- [ ] Protocol: 
- [ ] Nodes (Validators and Full nodes): 
- [ ] gRPC:
- [ ] JSON-RPC: 
- [ ] GraphQL: 
- [ ] CLI: 
- [ ] Rust SDK:

Author: stefan-mysten

Cargo.lock

@@ -13,6 +13,8 @@ serde_spanned.workspace = true
 toml.workspace = true
 anyhow.workspace = true
 derive-where.workspace = true
+thiserror.workspace = true
+codespan-reporting.workspace = true
 
 [dev-dependencies]
 move-command-line-common.workspace = true

external-crates/move/Cargo.lock

@@ -9,8 +9,6 @@ use std::path::{Path, PathBuf};
 use serde::{Deserialize, Serialize};
 use serde_spanned::Spanned;
 
-use crate::errors::Located;
-
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct LocalDependency {
     /// The path on the filesystem, relative to the location of the containing file (which is

external-crates/move/crates/move-package-alt/Cargo.toml

@@ -0,0 +1,68 @@
+// Copyright (c) The Diem Core Contributors
+// Copyright (c) The Move Contributors
+// SPDX-License-Identifier: Apache-2.0
+
+use std::{ops::Range, path::PathBuf};
+
+use codespan_reporting::{
+    diagnostic::{Diagnostic, Label},
+    files::SimpleFiles,
+    term::{
+        self,
+        termcolor::{ColorChoice, StandardStream},
+    },
+};
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+#[error("Invalid manifest: {kind}")]
+pub struct ManifestError {
+    pub kind: ManifestErrorKind,
+    pub span: Option<Range<usize>>,
+    pub path: PathBuf,
+    pub src: String,
+}
+
+#[derive(Error, Debug)]
+pub enum ManifestErrorKind {
+    #[error("package name cannot be empty")]
+    EmptyPackageName,
+    #[error("unsupported edition '{edition}', expected one of '{valid}'")]
+    InvalidEdition { edition: String, valid: String },
+}
+
+impl ManifestError {
+    /// Convert this error into a codespan Diagnostic
+    pub fn to_diagnostic(&self) -> Diagnostic<usize> {
+        let (file_id, span) = self.span_info();
+        Diagnostic::error()
+            .with_message(self.kind.to_string())
+            .with_labels(vec![Label::primary(file_id, span.unwrap_or_default())])
+    }
+
+    /// Get the file ID and span for this error
+    fn span_info(&self) -> (usize, Option<Range<usize>>) {
+        // In a real implementation, we'd want to cache the SimpleFiles instance
+        // and reuse it across multiple errors
+        let mut files = SimpleFiles::new();
+        let file_id = files.add(self.path.display().to_string(), self.src.clone());
+        (file_id, self.span.clone())
+    }
+
+    /// Emit this error to stderr
+    pub fn emit(&self) -> Result<(), codespan_reporting::files::Error> {
+        let mut files = SimpleFiles::new();
+        let file_id = files.add(self.path.display().to_string(), self.src.clone());
+
+        let writer = StandardStream::stderr(ColorChoice::Always);
+        let config = term::Config {
+            display_style: term::DisplayStyle::Rich,
+            chars: term::Chars::ascii(),
+            ..Default::default()
+        };
+
+        let diagnostic = self.to_diagnostic();
+        let e = term::emit(&mut writer.lock(), &config, &files, &diagnostic);
+        e
+    }
+}

external-crates/move/crates/move-package-alt/src/dependency/local.rs

@@ -0,0 +1,53 @@
+// Copyright (c) The Diem Core Contributors
+// Copyright (c) The Move Contributors
+// SPDX-License-Identifier: Apache-2.0
+
+mod manifest_error;
+pub use manifest_error::ManifestError;
+pub use manifest_error::ManifestErrorKind;
+
+use std::{ops::Range, path::PathBuf};
+
+use codespan_reporting::diagnostic::Diagnostic;
+use serde::{Deserialize, Serialize};
+use thiserror::Error;
+
+/// Result type for package operations
+pub type PackageResult<T> = Result<T, PackageError>;
+
+/// The main error type for package-related operations
+#[derive(Error, Debug)]
+pub enum PackageError {
+    #[error(transparent)]
+    Codespan(#[from] codespan_reporting::files::Error),
+
+    #[error(transparent)]
+    Io(#[from] std::io::Error),
+
+    #[error(transparent)]
+    Manifest(#[from] ManifestError),
+
+    #[error(transparent)]
+    Other(#[from] anyhow::Error),
+
+    #[error(transparent)]
+    Toml(#[from] toml_edit::de::Error),
+}
+
+impl PackageError {
+    pub fn to_diagnostic(&self) -> Diagnostic<usize> {
+        match self {
+            Self::Manifest(err) => err.to_diagnostic(),
+            _ => Diagnostic::error()
+                .with_message(self.to_string())
+                .with_labels(vec![]),
+        }
+    }
+
+    pub fn emit(&self) -> Result<(), codespan_reporting::files::Error> {
+        match self {
+            Self::Manifest(err) => err.emit(),
+            _ => Ok(()),
+        }
+    }
+}

external-crates/move/crates/move-package-alt/src/errors.rs

@@ -9,14 +9,18 @@ use std::{
 
 use derive_where::derive_where;
 use serde::{Deserialize, Serialize};
+use serde_spanned::Spanned;
 
 use crate::{
     dependency::ManifestDependencyInfo,
+    errors::{ManifestError, ManifestErrorKind, PackageResult},
     flavor::{MoveFlavor, Vanilla},
 };
 
 use super::*;
 
+const ALLOWED_EDITIONS: &[&str] = &["2024", "2024.beta", "legacy"];
+
 // Note: [Manifest] objects are immutable and should not implement [serde::Serialize]; any tool
 // writing these files should use [toml_edit] to set / preserve the formatting, since these are
 // user-editable files
@@ -36,8 +40,8 @@ pub struct Manifest<F: MoveFlavor> {
 #[derive(Debug, Deserialize)]
 #[serde(bound = "")]
 struct PackageMetadata<F: MoveFlavor> {
-    name: PackageName,
-    edition: String,
+    name: Spanned<PackageName>,
+    edition: Spanned<String>,
 
     #[serde(flatten)]
     metadata: F::PackageMetadata,
@@ -72,9 +76,45 @@ struct ManifestDependencyOverride<F: MoveFlavor> {
 }
 
 impl<F: MoveFlavor> Manifest<F> {
-    pub fn read_from(path: impl AsRef<Path>) -> anyhow::Result<Self> {
-        let contents = std::fs::read_to_string(path)?;
-        Ok(toml_edit::de::from_str(&contents)?)
+    pub fn read_from(path: impl AsRef<Path>) -> PackageResult<Self> {
+        let contents = std::fs::read_to_string(&path)?;
+
+        let manifest: Self = toml_edit::de::from_str(&contents)?;
+        manifest.validate_manifest(&path, &contents)?;
+
+        Ok(manifest)
+    }
+
+    /// Validate the manifest contents, after deserialization.
+    pub fn validate_manifest(&self, path: impl AsRef<Path>, contents: &str) -> PackageResult<()> {
+        // Validate package name
+        if self.package.name.get_ref().is_empty() {
+            let err = ManifestError {
+                kind: ManifestErrorKind::EmptyPackageName,
+                span: Some(self.package.name.span()),
+                path: path.as_ref().to_path_buf(),
+                src: contents.to_string(),
+            };
+            err.emit()?;
+            return Err(err.into());
+        }
+
+        // Validate edition
+        if !ALLOWED_EDITIONS.contains(&self.package.edition.get_ref().as_str()) {
+            let err = ManifestError {
+                kind: ManifestErrorKind::InvalidEdition {
+                    edition: self.package.edition.get_ref().clone(),
+                    valid: ALLOWED_EDITIONS.join(", ").to_string(),
+                },
+                span: Some(self.package.edition.span()),
+                path: path.as_ref().to_path_buf(),
+                src: contents.to_string(),
+            };
+            err.emit()?;
+            return Err(err.into());
+        }
+
+        Ok(())
     }
 
     fn write_template(path: impl AsRef<Path>, name: &PackageName) -> anyhow::Result<()> {

external-crates/move/crates/move-package-alt/src/errors/manifest_error.rs

@@ -1,7 +1,7 @@
 ---
-source: crates/move-package-alt/tests/manifest_parsing_tests.rs
+source: crates/move-package-alt/tests/parsing_tests.rs
 ---
-TOML parse error at line 8, column 11
+error: TOML parse error at line 8, column 11
   |
 8 | mainnet = 9123
   |           ^^^^

external-crates/move/crates/move-package-alt/src/errors/mod.rs

@@ -1,7 +1,7 @@
 ---
-source: crates/move-package-alt/tests/manifest_parsing_tests.rs
+source: crates/move-package-alt/tests/parsing_tests.rs
 ---
-TOML parse error at line 8, column 11
+error: TOML parse error at line 8, column 11
   |
 8 | mainnet = true
   |           ^^^^