include enums on directive args in schema introspection

modules/core/src/main/scala/sangria/schema/Schema.scala

@@ -1494,7 +1494,15 @@ case class Schema[Ctx, Val](
       .map(collectTypes("a subscription type", 10, _, queryAndSubTypes))
       .getOrElse(queryAndSubTypes)
 
-    queryAndSubAndMutTypes
+    val queryAndSubAndMutAndDirArgTypes = directives.foldLeft(queryAndSubAndMutTypes) {
+      case (acc, dir) =>
+        val argumentTypes = dir.arguments.map(_.argumentType)
+        argumentTypes.foldLeft(acc) { case (acc, arg) =>
+          collectTypes("an argument type", 10, arg, acc)
+        }
+    }
+
+    queryAndSubAndMutAndDirArgTypes
   }
 
   lazy val typeList: Vector[Type with Named] =

modules/core/src/test/scala/sangria/introspection/IntrospectionSpec.scala

@@ -1,6 +1,7 @@
 package sangria.introspection
 
 import sangria.execution.Executor
+import sangria.macros._
 import sangria.parser.QueryParser
 import sangria.schema._
 import sangria.util.FutureResultSupport
@@ -1257,6 +1258,56 @@ class IntrospectionSpec extends AnyWordSpec with Matchers with FutureResultSuppo
         "Null value was provided for the NotNull Type 'String!' at path 'name'.")
     }
 
+    "exposes enum types from AST based schema" in {
+      val ast = gql"""
+      enum SomeEnum {
+        FOO
+        BAR
+      }
+
+      directive @customDirective(something: SomeEnum!) on FIELD
+
+      type Query {
+        foo: String
+      }
+      """
+
+      val builder = AstSchemaBuilder.default[Any]
+      val schema = Schema.buildFromAst(ast, builder)
+
+      val Success(query) = QueryParser.parse("""{
+        __schema {
+            types {
+                kind
+                name
+                enumValues {
+                    name
+                }
+            }
+        }
+      } """)
+
+      val introspection = Executor.execute(schema, query).await
+
+      val types =
+        introspection
+          .asInstanceOf[Map[String, Any]]("data")
+          .asInstanceOf[Map[String, Any]]("__schema")
+          .asInstanceOf[Map[String, Any]]("types")
+          .asInstanceOf[Vector[Map[String, Any]]]
+
+      types should contain(
+        Map(
+          "kind" -> "ENUM",
+          "name" -> "SomeEnum",
+          "enumValues" -> Vector(
+            Map("name" -> "FOO"),
+            Map("name" -> "BAR")
+          )
+        )
+      )
+    }
+
     "exposes descriptions on types and fields" in {
       val schema =
         Schema(ObjectType("QueryRoot", fields[Unit, Unit](Field("foo", IntType, resolve = _ => 1))))