@@ -3,6 +3,7 @@ package graphql.kickstart.tools
 import graphql.kickstart.tools.resolver.FieldResolver
 import graphql.kickstart.tools.util.BiMap
 import graphql.kickstart.tools.util.JavaType
+import graphql.language.EnumTypeDefinition
 import graphql.language.FieldDefinition
 import graphql.language.ObjectTypeDefinition
 import graphql.language.SDLNamedDefinition
@@ -18,7 +19,8 @@ internal data class ScannedSchemaObjects(
     val customScalars: CustomScalarMap,
     val rootInfo: RootTypeInfo,
     val fieldResolversByType: Map<ObjectTypeDefinition, MutableMap<FieldDefinition, FieldResolver>>,
-    val unusedDefinitions: Set<TypeDefinition<*>>
+    val unusedDefinitions: Set<TypeDefinition<*>>,
+    val directiveOnlyEnums: Set<EnumTypeDefinition>
 )
 
 internal typealias TypeClassDictionary = BiMap<TypeDefinition<*>, JavaType>
 
@@ -171,15 +171,51 @@ internal class SchemaClassScanner(
             ?: error("No ${TypeDefinition::class.java.simpleName} for type name $inputTypeName")
         when (typeDefinition) {
             is ScalarTypeDefinition -> handleFoundScalarType(typeDefinition)
-            is EnumTypeDefinition -> handleDictionaryTypes(listOf(typeDefinition)) {
-                "Enum type '${it.name}' is used in a directive, but no class could be found for that type name. Please pass a class for type '${it.name}' in the parser's dictionary."
-            }
+            is EnumTypeDefinition -> handleDirectiveEnum(typeDefinition)
             is InputObjectTypeDefinition -> handleDictionaryTypes(listOf(typeDefinition)) {
                 "Input object type '${it.name}' is used in a directive, but no class could be found for that type name. Please pass a class for type '${it.name}' in the parser's dictionary."
             }
         }
     }
 
+    /**
+     * Directive argument values never reach resolver methods, so an enum used in a directive doesn't need a class. Without one
+     * it goes into [unvalidatedTypes] and, unless a field uses it too, is built with its value names as values, see
+     * [validateAndCreateResult].
+     */
+    private fun handleDirectiveEnum(type: EnumTypeDefinition) {
+        if (dictionary.containsKey(type)) {
+            return
+        }
+
+        val initialEntry = initialDictionary[type.name]
+        if (initialEntry != null) {
+            handleFoundType(type, initialEntry.get(), DictionaryReference())
+        } else {
+            unvalidatedTypes.add(type)
+        }
+    }
+
+    /**
+     * The names of the types used by the fields, arguments and input fields of [definitions], including fields added by extensions.
+     */
+    private fun typeNamesUsedByFields(definitions: Set<TypeDefinition<*>>): Set<String> {
+        val names = definitions.map { it.name }.toSet()
+        return (definitions + extensionDefinitions + inputExtensionDefinitions)
+            .filter { it.name in names }
+            .flatMap { definition ->
+                when (definition) {
+                    is ImplementingTypeDefinition<*> -> definition.fieldDefinitions.flatMap { field ->
+                        field.inputValueDefinitions.map { it.type } + field.type
+                    }
+                    is InputObjectTypeDefinition -> definition.inputValueDefinitions.map { it.type }
+                    else -> emptyList()
+                }
+            }
+            .mapNotNull { (it.unwrap() as TypeName).name }
+            .toSet()
+    }
+
     private fun validateAndCreateResult(rootTypeHolder: RootTypesHolder): ScannedSchemaObjects {
         initialDictionary
             .filter { !it.value.accessed }
@@ -246,7 +282,13 @@ internal class SchemaClassScanner(
 
         val definitions = observedDefinitions + extensionDefinitions + inputExtensionDefinitions + directiveDefinitions
 
-        return ScannedSchemaObjects(dictionary, definitions, scalars, rootInfo, fieldResolversByType.toMap(), unusedDefinitions)
+        // The enums in unvalidatedTypes come from directives without a class, so they can only be built when no field uses them.
+        // A field hands the enum's values to user code even when the scanner found no class through it, e.g. an input field bound
+        // to a Map or an unimplemented field's argument.
+        val typeNamesUsedByFields = typeNamesUsedByFields(observedDefinitions)
+        val directiveOnlyEnums = unvalidatedTypes.filterIsInstance<EnumTypeDefinition>().filter { it.name !in typeNamesUsedByFields }.toSet()
+
+        return ScannedSchemaObjects(dictionary, definitions, scalars, rootInfo, fieldResolversByType.toMap(), unusedDefinitions, directiveOnlyEnums)
     }
 
     private fun validateRootResolversWereUsed(rootType: RootType?, fieldResolvers: List<FieldResolver>) {
 
@@ -39,6 +39,7 @@ class SchemaParser internal constructor(
     private val rootInfo = scanResult.rootInfo
     private val fieldResolversByType = scanResult.fieldResolversByType
     private val unusedDefinitions = scanResult.unusedDefinitions
+    private val directiveOnlyEnums = scanResult.directiveOnlyEnums
 
     private val extensionDefinitions = definitions.filterIsInstance<ObjectTypeExtensionDefinition>()
     private val inputExtensionDefinitions = definitions.filterIsInstance<InputObjectTypeExtensionDefinition>()
@@ -198,9 +199,10 @@ class SchemaParser internal constructor(
 
     private fun createEnumObject(definition: EnumTypeDefinition): GraphQLEnumType {
         val name = definition.name
-        val type = dictionary[definition]
-            ?: throw SchemaError("Expected enum with name '$name' but found none!")
-        if (!type.unwrap().isEnum) throw SchemaError("Type '$name' is declared as an enum in the GraphQL schema but is not a Java enum!")
+        // enums only used by directives can do without a class, see SchemaClassScanner.handleDirectiveEnum
+        val enumClass = dictionary[definition]?.unwrap()
+        if (enumClass == null && definition !in directiveOnlyEnums) throw SchemaError("Expected enum with name '$name' but found none!")
+        if (enumClass != null && !enumClass.isEnum) throw SchemaError("Type '$name' is declared as an enum in the GraphQL schema but is not a Java enum!")
 
         val builder = GraphQLEnumType.newEnum()
             .name(name)
@@ -211,8 +213,12 @@ class SchemaParser internal constructor(
             .apply {
                 definition.enumValueDefinitions.forEach { valueDefinition ->
                     val enumName = valueDefinition.name
-                    val enumValue = type.unwrap().enumConstants.find { (it as Enum<*>).name == enumName }
-                        ?: throw SchemaError("Expected value for name '$enumName' in enum '${type.unwrap().simpleName}' but found none!")
+                    val enumValue = if (enumClass == null) {
+                        enumName
+                    } else {
+                        enumClass.enumConstants.find { (it as Enum<*>).name == enumName }
+                            ?: throw SchemaError("Expected value for name '$enumName' in enum '${enumClass.simpleName}' but found none!")
+                    }
 
                     value(
                         GraphQLEnumValueDefinition.newEnumValueDefinition()
 
@@ -2,6 +2,8 @@ package graphql.kickstart.tools
 
 import graphql.language.Definition
 import graphql.language.Document
+import graphql.language.SourceLocation
+import graphql.parser.InvalidSyntaxException
 import graphql.parser.MultiSourceReader
 import graphql.parser.Parser
 import graphql.parser.ParserEnvironment
@@ -11,6 +13,7 @@ import graphql.schema.idl.RuntimeWiring
 import graphql.schema.idl.SchemaDirectiveWiring
 import org.antlr.v4.runtime.RecognitionException
 import org.antlr.v4.runtime.misc.ParseCancellationException
+import java.text.NumberFormat
 import kotlin.Int.Companion.MAX_VALUE
 import kotlin.reflect.KClass
 
@@ -20,7 +23,7 @@ import kotlin.reflect.KClass
 class SchemaParserBuilder {
 
     private val dictionary = SchemaParserDictionary()
-    private val schemaString = StringBuilder()
+    private val schemaStrings = mutableListOf<Source>()
     private val files = mutableListOf<String>()
     private val resolvers = mutableListOf<GraphQLResolver<*>>()
     private val scalars = mutableListOf<GraphQLScalarType>()
@@ -49,10 +52,14 @@ class SchemaParserBuilder {
      * Add a GraphQL schema string directly.
      */
     fun schemaString(string: String) = this.apply {
-        if (schemaString.isNotEmpty()) {
-            schemaString.append("\n")
-        }
-        schemaString.append(string)
+        schemaStrings.add(Source(string, null))
+    }
+
+    /**
+     * Add a GraphQL schema string directly, naming its source in parse errors and source locations.
+     */
+    fun schemaString(string: String, sourceName: String) = this.apply {
+        schemaStrings.add(Source(string, sourceName))
     }
 
     /**
@@ -172,10 +179,10 @@ class SchemaParserBuilder {
 
     private fun parseDocuments(): List<Document> {
         try {
-            val documents = files.map { parseDocument(readFile(it), it) }.toMutableList()
+            val documents = files.map { parseDocument(listOf(Source(readFile(it), it))) }.toMutableList()
 
-            if (schemaString.isNotBlank()) {
-                documents.add(parseDocument(schemaString.toString()))
+            if (schemaStrings.any { it.text.isNotBlank() }) {
+                documents.add(parseDocument(schemaStrings))
             }
 
             return documents
@@ -189,16 +196,37 @@ class SchemaParserBuilder {
         }
     }
 
-    private fun parseDocument(input: String, sourceName: String? = null): Document {
-        val sourceReader = MultiSourceReader
-            .newMultiSourceReader()
-            .string(input, sourceName)
+    private fun parseDocument(sources: List<Source>): Document {
+        // graphql-java's MultiSourceReader numbers the last line of the last source from the start of the first one.
+        // Ending every source with a line break leaves only the end of input on that line, see syntaxErrorInSource.
+        val separated = if (sources.size > 1) sources.map { it.endingWithLineBreak() } else sources
+        val sourceReader = MultiSourceReader.newMultiSourceReader()
+            .apply { separated.forEach { string(it.text, it.name) } }
             .trackData(true).build()
         val environment = ParserEnvironment
             .newParserEnvironment()
             .document(sourceReader)
             .parserOptions(parserOptions).build()
-        return parser.parseDocument(environment)
+        try {
+            return parser.parseDocument(environment)
+        } catch (e: InvalidSyntaxException) {
+            throw syntaxErrorInSource(e, separated.last())
+        }
+    }
+
+    /**
+     * Makes the line of an unexpected end of input relative to the last source and adds the source name to the message.
+     */
+    private fun syntaxErrorInSource(e: InvalidSyntaxException, lastSource: Source): InvalidSyntaxException {
+        val location = e.location ?: return e
+        val line = if (e.offendingToken == "<EOF>") lastSource.text.lines().size else location.line
+        if (line == location.line && location.sourceName == null) return e
+
+        // graphql-java formats the line for the default locale, e.g. "1,103"
+        val number = NumberFormat.getInstance()
+        val message = e.message.orEmpty().replaceFirst(" ${number.format(location.line)} ", " ${number.format(line)} ")
+        val inSource = location.sourceName?.let { " in $it" }.orEmpty()
+        return SchemaSyntaxException(message + inSource, SourceLocation(line, location.column, location.sourceName), e)
     }
 
     private fun readFile(filename: String) =
@@ -209,6 +237,10 @@ class SchemaParserBuilder {
      * Build the parser with the supplied schema and dictionary.
      */
     fun build() = SchemaParser(scan(), options, runtimeWiringBuilder.build())
+
+    private data class Source(val text: String, val name: String?) {
+        fun endingWithLineBreak() = if (text.endsWith("\n")) this else copy(text = "$text\n")
+    }
 }
 
 class InvalidSchemaError(
@@ -218,3 +250,6 @@ class InvalidSchemaError(
     override val message: String
         get() = "Invalid schema provided (${recognitionException.javaClass.name}) at: ${recognitionException.offendingToken}"
 }
+
+internal class SchemaSyntaxException(message: String, location: SourceLocation, e: InvalidSyntaxException) :
+    InvalidSyntaxException(message, location, e.offendingToken, e.sourcePreview, e)