address comments

Author: bakkot

crates/volta-core/src/error/kind.rs

@@ -789,7 +789,7 @@ To {action} the packages '{name}' and '{version}', please {action} them in separ
 
                 let call_to_action = format!(
 "To {action} node version '{version}', please run `volta {action} {formatted}`. \
-To {action} the package '{version}', please use an explicit version such as '{version}@lts'.",
+To {action} the package '{version}', please use an explicit version such as '{version}@latest'.",
                     action=action,
                     version=version,
                     formatted=tool_version("node", version)

crates/volta-core/src/tool/serial.rs

@@ -90,45 +90,43 @@ impl Spec {
     where
         T: AsRef<str>,
     {
-        let mut args_iter = args.iter();
-
-        // The case we are concerned with here is where we have `<number>`.
-        // That is, exactly one argument, which is a valid version specifier.
-        //
-        // - `volta install node@12` is allowed.
-        // - `volta install 12` is an error.
-        // - `volta install lts` is an error.
-        if let (Some(maybe_version), None) = (args_iter.next(), args_iter.next()) {
-            if is_version_like(maybe_version.as_ref()) {
-                return Err(ErrorKind::InvalidInvocationOfBareVersion {
-                    action: action.to_string(),
-                    version: maybe_version.as_ref().to_string(),
+        let mut args = args.iter();
+
+        match (args.next(), args.next(), args.next()) {
+            (Some(maybe_version), None, None) => {
+                // The case we are concerned with here is where we have `<number>`.
+                // That is, exactly one argument, which is a valid version specifier.
+                //
+                // - `volta install node@12` is allowed.
+                // - `volta install 12` is an error.
+                // - `volta install lts` is an error.
+                if is_version_like(maybe_version.as_ref()) {
+                    return Err(ErrorKind::InvalidInvocationOfBareVersion {
+                        action: action.to_string(),
+                        version: maybe_version.as_ref().to_string(),
+                    }
+                    .into());
                 }
-                .into());
             }
-        }
-
-        args_iter = args.iter();
-
-        // The case we are concerned with here is where we have `<tool> <number>`.
-        // This is only interesting if there are exactly two args. Then we care
-        // whether the two items are a bare name (with no `@version`), followed
-        // by a valid version specifier (ignoring custom tags). That is:
-        //
-        // - `volta install node@lts latest` is allowed.
-        // - `volta install node latest` is an error.
-        // - `volta install node latest yarn` is allowed.
-        if let (Some(name), Some(maybe_version), None) =
-            (args_iter.next(), args_iter.next(), args_iter.next())
-        {
-            if !HAS_VERSION.is_match(name.as_ref()) && is_version_like(maybe_version.as_ref()) {
-                return Err(ErrorKind::InvalidInvocation {
-                    action: action.to_string(),
-                    name: name.as_ref().to_string(),
-                    version: maybe_version.as_ref().to_string(),
+            (Some(name), Some(maybe_version), None) => {
+                // The case we are concerned with here is where we have `<tool> <number>`.
+                // This is only interesting if there are exactly two args. Then we care
+                // whether the two items are a bare name (with no `@version`), followed
+                // by a valid version specifier (ignoring custom tags). That is:
+                //
+                // - `volta install node@lts latest` is allowed.
+                // - `volta install node latest` is an error.
+                // - `volta install node latest yarn` is allowed.
+                if !HAS_VERSION.is_match(name.as_ref()) && is_version_like(maybe_version.as_ref()) {
+                    return Err(ErrorKind::InvalidInvocation {
+                        action: action.to_string(),
+                        name: name.as_ref().to_string(),
+                        version: maybe_version.as_ref().to_string(),
+                    }
+                    .into());
                 }
-                .into());
             }
+            (_, _, _) => {}
         }
 
         Ok(())