Merge branch 'v-next' of github.com:NomicFoundation/hardhat into remove-defaultNetwork

Author: ChristopherDedominici

.changeset/green-hornets-joke.md

@@ -0,0 +1,6 @@
+---
+"@nomicfoundation/hardhat-errors": patch
+"hardhat": patch
+---
+
+Added support for short option names

.changeset/long-bats-nail.md

@@ -0,0 +1,6 @@
+---
+"hardhat": patch
+"@nomicfoundation/hardhat-typechain": patch
+---
+
+Added FLAG and LEVEL arguments types

v-next/hardhat-errors/src/descriptors.ts

@@ -738,6 +738,32 @@ Please double check your arguments.`,
           'The global option "--config" cannot be used with the "init" command',
         websiteDescription: `The global option "--config" cannot be used with the "init" command.
 
+Please double check your arguments.`,
+      },
+      CANNOT_GROUP_OPTIONS: {
+        number: 509,
+        messageTemplate:
+          'Invalid option "{option}". Options cannot be grouped together. Try providing the options separately.',
+        websiteTitle: "Options grouping is not supported",
+        websiteDescription: `Options cannot be grouped together.
+
+Please double check your arguments, and try providing the options separately.`,
+      },
+      CANNOT_REPEAT_OPTIONS: {
+        number: 510,
+        messageTemplate:
+          'Invalid option "{option}". Options of type "{type}" cannot be repeated.',
+        websiteTitle: "Options repetition is not supported",
+        websiteDescription: `Some options cannot be repeated.
+
+Please double check your arguments.`,
+      },
+      INVALID_SHORT_NAME: {
+        number: 511,
+        messageTemplate: `Argument short name "{name}" is invalid. It must consist of exactly one letter.`,
+        websiteTitle: "Invalid short argument name",
+        websiteDescription: `One of your Hardhat or task short argument names is invalid.
+
 Please double check your arguments.`,
       },
     },
@@ -979,7 +1005,7 @@ Remaining test suites: {suites}`,
 {error}`,
         websiteTitle: "Project file resolution error",
         websiteDescription: `There was an error while resolving the project file.
-        
+
 Please double-check your configuration. If it keeps happening, please report it.`,
       },
       NPM_ROOT_RESOLUTION_ERROR: {
@@ -989,7 +1015,7 @@ Please double-check your configuration. If it keeps happening, please report it.
 {error}`,
         websiteTitle: "Npm file resolution error",
         websiteDescription: `There was an error while resolving an npm module that you are trying to compile and generate artifacts for.
-        
+
 Please double-check your configuration. If it keeps happening, please report it.`,
       },
       IMPORT_RESOLUTION_ERROR: {

v-next/hardhat-typechain/src/index.ts

@@ -1,8 +1,7 @@
 import type { HardhatPlugin } from "hardhat/types/plugins";
 
 import "./type-extensions.js";
-import { globalOption } from "hardhat/config";
-import { ArgumentType } from "hardhat/types/arguments";
+import { globalFlag } from "hardhat/config";
 
 const hardhatTypechain: HardhatPlugin = {
   id: "hardhat-typechain",
@@ -15,11 +14,9 @@ const hardhatTypechain: HardhatPlugin = {
     async () => (await import("@nomicfoundation/hardhat-ethers")).default,
   ],
   globalOptions: [
-    globalOption({
+    globalFlag({
       name: "noTypechain",
       description: "Disables the typechain type generation",
-      defaultValue: false,
-      type: ArgumentType.BOOLEAN,
     }),
   ],
 };

v-next/hardhat/src/internal/builtin-global-options.ts

@@ -1,6 +1,6 @@
 import type { GlobalOptionDefinitions } from "../types/global-options.js";
 
-import { globalOption } from "../config.js";
+import { globalFlag, globalOption } from "../config.js";
 import { ArgumentType } from "../types/arguments.js";
 
 export const BUILTIN_GLOBAL_OPTIONS_DEFINITIONS: GlobalOptionDefinitions =
@@ -21,60 +21,50 @@ export const BUILTIN_GLOBAL_OPTIONS_DEFINITIONS: GlobalOptionDefinitions =
       "help",
       {
         pluginId: "builtin",
-        option: globalOption({
+        option: globalFlag({
           name: "help",
           description:
             "Shows this message, or a task's help if its name is provided.",
-          type: ArgumentType.BOOLEAN,
-          defaultValue: false,
         }),
       },
     ],
     [
       "init",
       {
         pluginId: "builtin",
-        option: globalOption({
+        option: globalFlag({
           name: "init",
           description: "Initializes a Hardhat project.",
-          type: ArgumentType.BOOLEAN,
-          defaultValue: false,
         }),
       },
     ],
     [
       "showStackTraces",
       {
         pluginId: "builtin",
-        option: globalOption({
+        option: globalFlag({
           name: "showStackTraces",
           description: "Show stack traces (always enabled on CI servers).",
-          type: ArgumentType.BOOLEAN,
-          defaultValue: false,
         }),
       },
     ],
     [
       "verbose",
       {
         pluginId: "builtin",
-        option: globalOption({
+        option: globalFlag({
           name: "verbose",
           description: "Enables Hardhat verbose logging.",
-          type: ArgumentType.BOOLEAN,
-          defaultValue: false,
         }),
       },
     ],
     [
       "version",
       {
         pluginId: "builtin",
-        option: globalOption({
+        option: globalFlag({
           name: "version",
           description: "Shows hardhat's version.",
-          type: ArgumentType.BOOLEAN,
-          defaultValue: false,
         }),
       },
     ],

v-next/hardhat/src/internal/builtin-plugins/coverage/index.ts

@@ -1,19 +1,16 @@
 import type { HardhatPlugin } from "../../../types/plugins.js";
 
-import { ArgumentType } from "../../../types/arguments.js";
-import { globalOption } from "../../core/config.js";
+import { globalFlag } from "../../core/config.js";
 
 import "./type-extensions.js";
 
 const hardhatPlugin: HardhatPlugin = {
   id: "builtin:coverage",
   tasks: [],
   globalOptions: [
-    globalOption({
+    globalFlag({
       name: "coverage",
       description: "Enables code coverage",
-      type: ArgumentType.BOOLEAN,
-      defaultValue: false,
     }),
   ],
   hookHandlers: {

v-next/hardhat/src/internal/cli/help/utils.ts

@@ -11,6 +11,7 @@ export const GLOBAL_NAME_PADDING = 6;
 
 interface ArgumentDescriptor {
   name: string;
+  shortName?: string;
   description: string;
   type?: ArgumentType;
   defaultValue?: ArgumentTypeToValueType<ArgumentType>;
@@ -22,6 +23,7 @@ export function parseGlobalOptions(
 ): ArgumentDescriptor[] {
   return [...globalOptionDefinitions].map(([, { option }]) => ({
     name: toCommandLineOption(option.name),
+    shortName: toShortCommandLineOption(option.shortName),
     description: option.description,
   }));
 }
@@ -69,6 +71,7 @@ export function parseOptions(task: Task): {
   for (const [optionName, option] of task.options) {
     options.push({
       name: toCommandLineOption(optionName),
+      shortName: toShortCommandLineOption(option.shortName),
       description: option.description,
       type: option.type,
       ...(option.defaultValue !== undefined && {
@@ -97,8 +100,20 @@ export function toCommandLineOption(optionName: string): string {
   return `--${camelToKebabCase(optionName)}`;
 }
 
-export function getLongestNameLength(tasks: Array<{ name: string }>): number {
-  return tasks.reduce((acc, { name }) => Math.max(acc, name.length), 0);
+export function toShortCommandLineOption(
+  optionShortName?: string,
+): string | undefined {
+  return optionShortName !== undefined ? `-${optionShortName}` : undefined;
+}
+
+export function getLongestNameLength(
+  tasks: Array<{ name: string; shortName?: string }>,
+): number {
+  return tasks.reduce(
+    (acc, { name, shortName }) =>
+      Math.max(acc, getNameString(name, shortName).length),
+    0,
+  );
 }
 
 export function getSection(
@@ -108,13 +123,18 @@ export function getSection(
 ): string {
   return `\n${title}:\n\n${items
     .sort((a, b) => a.name.localeCompare(b.name))
-    .map(({ name, description, defaultValue }) => {
+    .map(({ name, shortName, description, defaultValue }) => {
+      const nameStr = getNameString(name, shortName);
       const defaultValueStr = getDefaultValueString(defaultValue);
-      return `  ${name.padEnd(namePadding)}${description}${defaultValueStr}`;
+      return `  ${nameStr.padEnd(namePadding)}${description}${defaultValueStr}`.trimEnd();
     })
     .join("\n")}\n`;
 }
 
+function getNameString(name: string, shortName?: string): string {
+  return shortName !== undefined ? [name, shortName].join(", ") : name;
+}
+
 function getDefaultValueString(
   defaultValue: ArgumentTypeToValueType<ArgumentType>,
 ): string {
@@ -143,7 +163,15 @@ export function getUsageString(
   if (options.length > 0) {
     output += ` ${options
       .sort((a, b) => a.name.localeCompare(b.name))
-      .map((o) => `[${o.name}${o.type === "BOOLEAN" ? "" : ` <${o.type}>`}]`)
+      .map((o) => {
+        // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- We want to explicitly handle all the other types via the default case
+        switch (o.type) {
+          case "FLAG":
+            return `[${o.name}]`;
+          default:
+            return `[${o.name} <${o.type}>]`;
+        }
+      })
       .join(" ")}`;
   }
 

v-next/hardhat/src/internal/cli/main.ts

@@ -372,12 +372,12 @@ function getTaskFromCliArguments(
 
     const arg = cliArguments[i];
 
-    if (arg.startsWith("--")) {
+    if (arg.startsWith("-")) {
       /* A standalone '--' is ok because it is used to separate CLI tool arguments
        * from task arguments, ensuring the tool passes subsequent options directly
        * to the task. Everything after "--" should be considered as a positional
        * argument. */
-      if (arg.length === 2 || task !== undefined) {
+      if (arg === "--" || task !== undefined) {
         break;
       }
 
@@ -474,6 +474,16 @@ function parseOptions(
   providedArguments: TaskArguments,
   ignoreUnknownOption = false,
 ) {
+  const optionDefinitionsByShortName = new Map<string, OptionDefinition>();
+  for (const optionDefinition of optionDefinitions.values()) {
+    if (optionDefinition.shortName !== undefined) {
+      optionDefinitionsByShortName.set(
+        optionDefinition.shortName,
+        optionDefinition,
+      );
+    }
+  }
+
   for (let i = 0; i < cliArguments.length; i++) {
     if (usedCliArguments[i]) {
       continue;
@@ -489,13 +499,32 @@ function parseOptions(
 
     const arg = cliArguments[i];
 
-    if (arg.startsWith("--") === false) {
+    let optionDefinition: OptionDefinition | undefined;
+
+    const providedByName = arg.startsWith("--");
+    const providedByShortName = !providedByName && arg.startsWith("-");
+
+    if (providedByName) {
+      const name = kebabToCamelCase(arg.substring(2));
+      optionDefinition = optionDefinitions.get(name);
+    } else if (providedByShortName) {
+      const shortName = arg[1];
+
+      // Check if the short name is valid
+      if (Array.from(arg.substring(1)).some((c) => c !== shortName)) {
+        throw new HardhatError(
+          HardhatError.ERRORS.CORE.ARGUMENTS.CANNOT_GROUP_OPTIONS,
+          {
+            option: arg,
+          },
+        );
+      }
+
+      optionDefinition = optionDefinitionsByShortName.get(shortName);
+    } else {
       continue;
     }
 
-    const optionName = kebabToCamelCase(arg.substring(2));
-    const optionDefinition = optionDefinitions.get(optionName);
-
     if (optionDefinition === undefined) {
       if (ignoreUnknownOption === true) {
         continue;
@@ -511,32 +540,38 @@ function parseOptions(
       );
     }
 
-    usedCliArguments[i] = true;
+    const optionName = optionDefinition.name;
 
-    if (optionDefinition.type === ArgumentType.BOOLEAN) {
-      if (
-        usedCliArguments[i + 1] !== undefined &&
-        usedCliArguments[i + 1] === false &&
-        (cliArguments[i + 1] === "true" || cliArguments[i + 1] === "false")
-      ) {
-        // The argument could be followed by a boolean value if it does not
-        // behaves like a flag
-        providedArguments[optionName] = parseArgumentValue(
-          cliArguments[i + 1],
-          ArgumentType.BOOLEAN,
-          optionName,
-        );
+    // Check if the short name is valid again now that we know its type
+    // E.g. --flag --flag
+    const optionAlreadyProvided = providedArguments[optionName] !== undefined;
+    // E.g. -ff
+    const shortOptionGroupedAndRepeated = providedByShortName && arg.length > 2;
+    const isLevelOption = optionDefinition.type === ArgumentType.LEVEL;
+    if (
+      optionAlreadyProvided ||
+      (shortOptionGroupedAndRepeated && !isLevelOption)
+    ) {
+      throw new HardhatError(
+        HardhatError.ERRORS.CORE.ARGUMENTS.CANNOT_REPEAT_OPTIONS,
+        {
+          option: arg,
+          type: optionDefinition.type,
+        },
+      );
+    }
 
-        usedCliArguments[i + 1] = true;
-        continue;
-      }
+    usedCliArguments[i] = true;
 
-      if (optionDefinition.defaultValue === false) {
-        // If the default value for the argument is false, the argument behaves
-        // like a flag, so there is no need to specify the value
-        providedArguments[optionName] = true;
-        continue;
-      }
+    if (optionDefinition.type === ArgumentType.FLAG) {
+      providedArguments[optionName] = true;
+      continue;
+    } else if (
+      optionDefinition.type === ArgumentType.LEVEL &&
+      providedByShortName
+    ) {
+      providedArguments[optionName] = arg.length - 1;
+      continue;
     } else if (
       usedCliArguments[i + 1] !== undefined &&
       usedCliArguments[i + 1] === false