Moving all the exhaustive coverage check to the tests

Author: Janther

.c8rc

@@ -5,7 +5,7 @@
   "functions": 90,
   "statements": 90,
   "exclude": ["/node_modules/"],
-  "include": ["src/**/*.ts"],
+  "include": ["src/**/*.ts", "check-coverage/**/*.ts"],
   "reporter": ["lcov", "text"],
   "temp-dir": "./coverage/"
 }

check-coverage/ArgumentsDeclaration.ts

@@ -0,0 +1,12 @@
+import * as ast from '@nomicfoundation/slang/ast';
+
+// This is to ensure that we have handled all variants of
+// `ArgumentsDeclaration`.
+export function checkArgumentsDeclarationVariant(
+  variant: ast.ArgumentsDeclaration['variant']
+): void {
+  if (variant instanceof ast.PositionalArgumentsDeclaration) return;
+  if (variant instanceof ast.NamedArgumentsDeclaration) return;
+  /* c8 ignore next 2 */
+  const _exhaustiveCheck: never = variant;
+}

check-coverage/ContractMember.ts

@@ -0,0 +1,22 @@
+import * as ast from '@nomicfoundation/slang/ast';
+
+// This is to ensure that we have handled all variants of `ContractMember`.
+export function checkContractMemberVariant(
+  variant: ast.ContractMember['variant']
+): void {
+  if (variant instanceof ast.UsingDirective) return;
+  if (variant instanceof ast.FunctionDefinition) return;
+  if (variant instanceof ast.ConstructorDefinition) return;
+  if (variant instanceof ast.ReceiveFunctionDefinition) return;
+  if (variant instanceof ast.FallbackFunctionDefinition) return;
+  if (variant instanceof ast.UnnamedFunctionDefinition) return;
+  if (variant instanceof ast.ModifierDefinition) return;
+  if (variant instanceof ast.StructDefinition) return;
+  if (variant instanceof ast.EnumDefinition) return;
+  if (variant instanceof ast.EventDefinition) return;
+  if (variant instanceof ast.StateVariableDefinition) return;
+  if (variant instanceof ast.ErrorDefinition) return;
+  if (variant instanceof ast.UserDefinedValueTypeDefinition) return;
+  /* c8 ignore next 2 */
+  const _exhaustiveCheck: never = variant;
+}

check-coverage/ContractSpecifier.ts

@@ -0,0 +1,11 @@
+import * as ast from '@nomicfoundation/slang/ast';
+
+// This is to ensure that we have handled all variants of `ContractSpecifier`.
+export function checkContractSpecifierVariant(
+  variant: ast.ContractSpecifier['variant']
+): void {
+  if (variant instanceof ast.InheritanceSpecifier) return;
+  if (variant instanceof ast.StorageLayoutSpecifier) return;
+  /* c8 ignore next 2 */
+  const _exhaustiveCheck: never = variant;
+}

check-coverage/Expression.ts

@@ -0,0 +1,38 @@
+import * as ast from '@nomicfoundation/slang/ast';
+import { TerminalNode } from '@nomicfoundation/slang/cst';
+
+// This is to ensure that we have handled all variants of `Expression`.
+export function checkExpressionVariant(
+  variant: ast.Expression['variant']
+): void {
+  if (variant instanceof TerminalNode) return;
+  if (variant instanceof ast.AssignmentExpression) return;
+  if (variant instanceof ast.ConditionalExpression) return;
+  if (variant instanceof ast.OrExpression) return;
+  if (variant instanceof ast.AndExpression) return;
+  if (variant instanceof ast.EqualityExpression) return;
+  if (variant instanceof ast.InequalityExpression) return;
+  if (variant instanceof ast.BitwiseOrExpression) return;
+  if (variant instanceof ast.BitwiseXorExpression) return;
+  if (variant instanceof ast.BitwiseAndExpression) return;
+  if (variant instanceof ast.ShiftExpression) return;
+  if (variant instanceof ast.AdditiveExpression) return;
+  if (variant instanceof ast.MultiplicativeExpression) return;
+  if (variant instanceof ast.ExponentiationExpression) return;
+  if (variant instanceof ast.PostfixExpression) return;
+  if (variant instanceof ast.PrefixExpression) return;
+  if (variant instanceof ast.FunctionCallExpression) return;
+  if (variant instanceof ast.CallOptionsExpression) return;
+  if (variant instanceof ast.MemberAccessExpression) return;
+  if (variant instanceof ast.IndexAccessExpression) return;
+  if (variant instanceof ast.NewExpression) return;
+  if (variant instanceof ast.TupleExpression) return;
+  if (variant instanceof ast.TypeExpression) return;
+  if (variant instanceof ast.ArrayExpression) return;
+  if (variant instanceof ast.HexNumberExpression) return;
+  if (variant instanceof ast.DecimalNumberExpression) return;
+  if (variant instanceof ast.StringExpression) return;
+  if (variant instanceof ast.ElementaryType) return;
+  /* c8 ignore next 2 */
+  const _exhaustiveCheck: never = variant;
+}

check-coverage/FallbackFunctionAttribute.ts

@@ -0,0 +1,14 @@
+import * as ast from '@nomicfoundation/slang/ast';
+import { TerminalNode } from '@nomicfoundation/slang/cst';
+
+// This is to ensure that we have handled all variants of
+// `FallbackFunctionAttribute`.
+export function checkFallbackFunctionAttributeVariant(
+  variant: ast.FallbackFunctionAttribute['variant']
+): void {
+  if (variant instanceof TerminalNode) return;
+  if (variant instanceof ast.ModifierInvocation) return;
+  if (variant instanceof ast.OverrideSpecifier) return;
+  /* c8 ignore next 2 */
+  const _exhaustiveCheck: never = variant;
+}

check-coverage/ForStatementInitialization.ts

@@ -0,0 +1,15 @@
+import * as ast from '@nomicfoundation/slang/ast';
+import { TerminalNode } from '@nomicfoundation/slang/cst';
+
+// This is to ensure that we have handled all variants of
+// `ForStatementInitialization`.
+export function checkForStatementInitializationVariant(
+  variant: ast.ForStatementInitialization['variant']
+): void {
+  if (variant instanceof TerminalNode) return;
+  if (variant instanceof ast.ExpressionStatement) return;
+  if (variant instanceof ast.VariableDeclarationStatement) return;
+  if (variant instanceof ast.TupleDeconstructionStatement) return;
+  /* c8 ignore next 2 */
+  const _exhaustiveCheck: never = variant;
+}

check-coverage/FunctionAttribute.ts

@@ -0,0 +1,13 @@
+import * as ast from '@nomicfoundation/slang/ast';
+import { TerminalNode } from '@nomicfoundation/slang/cst';
+
+// This is to ensure that we have handled all variants of `FunctionAttribute`.
+export function checkFunctionAttributeVariant(
+  variant: ast.FunctionAttribute['variant']
+): void {
+  if (variant instanceof TerminalNode) return;
+  if (variant instanceof ast.ModifierInvocation) return;
+  if (variant instanceof ast.OverrideSpecifier) return;
+  /* c8 ignore next 2 */
+  const _exhaustiveCheck: never = variant;
+}

check-coverage/ImportClause.ts

@@ -0,0 +1,12 @@
+import * as ast from '@nomicfoundation/slang/ast';
+
+// This is to ensure that we have handled all variants of `ImportClause`.
+export function checkImportClauseVariant(
+  variant: ast.ImportClause['variant']
+): void {
+  if (variant instanceof ast.PathImport) return;
+  if (variant instanceof ast.NamedImport) return;
+  if (variant instanceof ast.ImportDeconstruction) return;
+  /* c8 ignore next 2 */
+  const _exhaustiveCheck: never = variant;
+}

check-coverage/MappingKeyType.ts

@@ -0,0 +1,11 @@
+import * as ast from '@nomicfoundation/slang/ast';
+
+// This is to ensure that we have handled all variants of `MappingKeyType`.
+export function checkMappingKeyTypeVariant(
+  variant: ast.MappingKeyType['variant']
+): void {
+  if (variant instanceof ast.IdentifierPath) return;
+  if (variant instanceof ast.ElementaryType) return;
+  /* c8 ignore next 2 */
+  const _exhaustiveCheck: never = variant;
+}