Struct LockFile 

pub struct LockFile {
    pub dependencies: BTreeMap<String, LockFileDep>,
    pub packages: BTreeMap<EntryName, LockFileEntry>,
}

A lock file, specifying versions and names for all recursive dependencies.

This defines the on-disk format for lock files.

Open question

There’s one big open question about the lock file: should it contain information about path dependencies (and their recursive dependencies)? If it does, you can immediately derive the PackageMap from the lock file, meaning that if the interpreter gets the lock file then it can do everything else from there, without doing any package resolution. So that’s nice.

The problem with putting information about path dependencies in the lock file is that path dependencies can change without notice, making the lock file stale. So the interpreter didn’t have to do much work, but it ended up running on old information.

I think the decision here basically comes down to what we want from the CLI interface. If we require a separate update-the-lock-file step (a la npm or poetry), it makes sense to put the path dependency info here. But if we want an auto-refresh step (a la cargo), we want to leave it out.

Fields

dependencies: BTreeMap<String, LockFileDep>

The dependencies of the current (top-level) package.

These should be sorted so that the serialization doesn’t change all the time.

packages: BTreeMap<EntryName, LockFileEntry>

All packages that we know about, and the dependencies of each one.

Note that the package list is not guaranteed to be closed: path dependencies cannot have their dependencies resolved in the on-disk lockfile because they can change at any time. Some path dependencies (for example, path dependencies that are local to a git dependency repo) may have resolved dependencies.

Implementations

impl LockFile

pub fn empty() -> Self

pub fn new( manifest: &ManifestFile, resolution: &Resolution, ) -> Result<Self, Error>

pub fn from_path(path: impl AsRef<Path>) -> Result<Self, Error>

Read a lock file from disk.

pub fn write(&self, path: &Path) -> Result<(), Error>

Write out this lock file to the filesystem.

pub fn dependency<'a>( &'a self, entry: Option<&'a LockFileEntry>, name: &str, ) -> Option<&'a LockFileDep>

Trait Implementations

impl Clone for LockFile

fn clone(&self) -> LockFile

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for LockFile

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for LockFile

fn default() -> LockFile

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for LockFile

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for LockFile

impl PartialEq for LockFile

fn eq(&self, other: &LockFile) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for LockFile

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for LockFile