feat: add discriminator support for JSON schema validation

Author: mohankumarelec

src/jsonSchema.ts

@@ -88,6 +88,7 @@ export interface JSONSchema {
 	allowComments?: boolean; // VSCode extension
 	allowTrailingCommas?: boolean; // VSCode extension
 	completionDetail?: string; // VSCode extension
+	discriminator?: { propertyName?: string; propertyIndex?: number; mapping?: { [value: string]: number }; }; // VSCode extension
 }
 
 export interface JSONSchemaMap {

src/parser/jsonParser.ts

@@ -485,9 +485,59 @@ function validate(n: ASTNode | undefined, schema: JSONSchema, validationResult:
 		const testAlternatives = (alternatives: JSONSchemaRef[], maxOneMatch: boolean) => {
 			const matches = [];
 
+			// Apply discriminator optimization if available
+			const discriminator = schema.discriminator;
+			let alternativesToTest = alternatives;
+
+			if (discriminator) {
+				// Extract discriminator value from node
+				let discriminatorValue: string | undefined;
+				if (node.type === 'object' && discriminator.propertyName) {
+					const prop = node.properties.find(p => p.keyNode.value === discriminator.propertyName);
+					if (prop?.valueNode?.type === 'string') {
+						discriminatorValue = prop.valueNode.value;
+					}
+				} else if (node.type === 'array' && discriminator.propertyIndex !== undefined) {
+					const item = node.items[discriminator.propertyIndex];
+					if (item?.type === 'string') {
+						discriminatorValue = item.value;
+					}
+				}
+
+				if (discriminatorValue !== undefined) {
+					// Use explicit mapping if available
+					if (discriminator.mapping) {
+						const index = discriminator.mapping[discriminatorValue];
+						if (index !== undefined && index >= 0 && index < alternatives.length) {
+							alternativesToTest = [alternatives[index]];
+						}
+					} else {
+						// Auto-detect matching schemas
+						const matchingIndices = [];
+						for (let i = 0; i < alternatives.length; i++) {
+							const altSchema = asSchema(alternatives[i]);
+							if (discriminator.propertyName && altSchema.properties?.[discriminator.propertyName]) {
+								if (asSchema(altSchema.properties[discriminator.propertyName]).const === discriminatorValue) {
+									matchingIndices.push(i);
+								}
+							} else if (discriminator.propertyIndex !== undefined) {
+								const itemSchema = altSchema.prefixItems?.[discriminator.propertyIndex]
+									?? (Array.isArray(altSchema.items) ? altSchema.items[discriminator.propertyIndex] : undefined);
+								if (itemSchema && asSchema(itemSchema).const === discriminatorValue) {
+									matchingIndices.push(i);
+								}
+							}
+						}
+						if (matchingIndices.length > 0) {
+							alternativesToTest = matchingIndices.map(i => alternatives[i]);
+						}
+					}
+				}
+			}
+
 			// remember the best match that is used for error messages
 			let bestMatch: { schema: JSONSchema; validationResult: ValidationResult; matchingSchemas: ISchemaCollector; } | undefined = undefined;
-			for (const subSchemaRef of alternatives) {
+			for (const subSchemaRef of alternativesToTest) {
 				const subSchema = asSchema(subSchemaRef);
 				const subValidationResult = new ValidationResult();
 				const subMatchingSchemas = matchingSchemas.newSub();