fix: correct vocabulary and draft-based keyword gating for JSON Schema 2019-09+

- Gate dependentRequired, dependentSchemas, unevaluatedProperties,
  unevaluatedItems, minContains, maxContains to 2019-09+
- Gate prefixItems to 2020-12+
- Gate dependencies to draft-07 and earlier
- Apply vocabulary filtering only for 2019-09+ schemas
- Make format annotation-only by default for 2019-09+ per spec
- Support enabling format assertion via $vocabulary
- Stop treating $id fragments as anchors in 2019-09+
- Fix relative $id resolution when reached via JSON pointer $ref
- Highlight full object range for required property errors

Author: Keegan Caruso

src/parser/jsonParser.ts

@@ -216,11 +216,12 @@ export interface ISchemaCollector {
 
 export interface IEvaluationContext {
 	readonly schemaDraft: SchemaDraft;
+	readonly explicitSchemaDraft?: SchemaDraft;
 	readonly activeVocabularies?: Vocabularies;
 }
 
 class EvaluationContext implements IEvaluationContext {
-	constructor(public readonly schemaDraft: SchemaDraft, public readonly activeVocabularies?: Vocabularies) {
+	constructor(public readonly schemaDraft: SchemaDraft, public readonly activeVocabularies?: Vocabularies, public readonly explicitSchemaDraft?: SchemaDraft) {
 	}
 }
 
@@ -382,7 +383,8 @@ export class JSONDocument {
 	public validate(textDocument: TextDocument, schema: JSONSchema | undefined, severity: DiagnosticSeverity = DiagnosticSeverity.Warning, schemaDraft?: SchemaDraft, activeVocabularies?: Vocabularies): Diagnostic[] | undefined {
 		if (this.root && schema) {
 			const validationResult = new ValidationResult();
-			const context = new EvaluationContext(schemaDraft ?? getSchemaDraft(schema), activeVocabularies);
+			const { explicitDraft, effectiveDraft } = resolveDrafts(schema, schemaDraft);
+			const context = new EvaluationContext(effectiveDraft, activeVocabularies, explicitDraft);
 			const schemaStack: JSONSchema[] = [];
 			const schemaRoots: JSONSchema[] = [schema];
 			validate(this.root, schema, validationResult, NoOpSchemaCollector.instance, context, schemaStack, schemaRoots);
@@ -397,8 +399,8 @@ export class JSONDocument {
 	public getMatchingSchemas(schema: JSONSchema, focusOffset: number = -1, exclude?: ASTNode, activeVocabularies?: Vocabularies): IApplicableSchema[] {
 		if (this.root && schema) {
 			const matchingSchemas = new SchemaCollector(focusOffset, exclude);
-			const schemaDraft = getSchemaDraft(schema);
-			const context = new EvaluationContext(schemaDraft, activeVocabularies);
+			const { explicitDraft, effectiveDraft } = resolveDrafts(schema);
+			const context = new EvaluationContext(effectiveDraft, activeVocabularies, explicitDraft);
 			const schemaStack: JSONSchema[] = [];
 			const schemaRoots: JSONSchema[] = [schema];
 			validate(this.root, schema, new ValidationResult(), matchingSchemas, context, schemaStack, schemaRoots);
@@ -407,14 +409,29 @@ export class JSONDocument {
 		return [];
 	}
 }
-function getSchemaDraft(schema: JSONSchema, fallBack = SchemaDraft.v2020_12) {
-	let schemaId = schema.$schema;
-	if (schemaId) {
-		return getSchemaDraftFromId(schemaId) ?? fallBack;
-	}
-	return fallBack;
+
+/*
+ * Resolves the schema draft versions for validation.
+ * - explicitDraft: the draft explicitly declared via $schema or passed as an override.
+ *   Undefined when no $schema is present and no override is provided.
+ * - effectiveDraft: the draft used for keyword gating, defaulting to 2020-12.
+ * These are tracked separately so that behaviors like format assertion can
+ * distinguish "explicitly 2020-12" (annotation-only per spec) from
+ * "no $schema, defaulting to 2020-12" (asserts for backward compatibility).
+ */
+function resolveDrafts(schema: JSONSchema, schemaDraftOverride?: SchemaDraft): { explicitDraft: SchemaDraft | undefined; effectiveDraft: SchemaDraft } {
+	const explicitDraft = schemaDraftOverride ?? (schema.$schema ? getSchemaDraftFromId(schema.$schema) : undefined);
+	const effectiveDraft = explicitDraft ?? SchemaDraft.v2020_12;
+	return { explicitDraft, effectiveDraft };
 }
 
+// Keywords introduced in 2019-09 (not available in draft-07 and earlier)
+const keywords201909 = new Set([
+	'dependentRequired', 'dependentSchemas',
+	'unevaluatedProperties', 'unevaluatedItems',
+	'minContains', 'maxContains'
+]);
+
 function validate(n: ASTNode | undefined, schema: JSONSchema, validationResult: ValidationResult, matchingSchemas: ISchemaCollector, context: IEvaluationContext, schemaStack: JSONSchema[], schemaRoots: JSONSchema[]): void {
 
 	if (!n || !matchingSchemas.include(n)) {
@@ -455,14 +472,29 @@ function validate(n: ASTNode | undefined, schema: JSONSchema, validationResult:
 	schemaStack.push(schema);
 
 	const enabled = (keyword: string) => {
-		// Special case for 'dependencies' which is a core keyword in draft-04 through draft-07 but moved to 
-		// dependentSchemas and dependentRequired in later versions.		
-		if (keyword === 'dependencies')
-		{
+		// Draft-based keyword gating: keywords only exist in certain drafts.
+		// 'dependencies' was replaced by dependentRequired/dependentSchemas in 2019-09
+		if (keyword === 'dependencies') {
 			return context.schemaDraft <= SchemaDraft.v7;
 		}
-			
-		return isKeywordEnabled(keyword, context.activeVocabularies);
+
+		// Keywords introduced in 2019-09 (not available in draft-07 and earlier)
+		if (keywords201909.has(keyword)) {
+			return context.schemaDraft >= SchemaDraft.v2019_09;
+		}
+
+		// 'prefixItems' was introduced in 2020-12
+		if (keyword === 'prefixItems') {
+			return context.schemaDraft >= SchemaDraft.v2020_12;
+		}
+
+		// Vocabulary-based filtering only applies for 2019-09+ (vocabulary is not a concept in older drafts)
+		if (context.schemaDraft >= SchemaDraft.v2019_09 && context.activeVocabularies) {
+			return isKeywordEnabled(keyword, context.activeVocabularies);
+		}
+
+		// No vocabulary info or pre-2019-09: enable all draft-appropriate keywords
+		return true;
 	};
 
 	_validateNode();
@@ -859,7 +891,7 @@ function validate(n: ASTNode | undefined, schema: JSONSchema, validationResult:
 		}
 
 		// Only validate format if format-assertion vocabulary is active (not annotation-only)
-		if (schema.format && enabled('format') && isFormatAssertionEnabled(context.activeVocabularies)) {
+		if (schema.format && enabled('format') && isFormatAssertionEnabled(context.activeVocabularies, context.explicitSchemaDraft)) {
 			switch (schema.format) {
 				case 'uri':
 				case 'uri-reference': {
@@ -1055,7 +1087,7 @@ function validate(n: ASTNode | undefined, schema: JSONSchema, validationResult:
 			for (const propertyName of schema.required) {
 				if (!seenKeys[propertyName]) {
 					validationResult.problems.push({
-						location: { offset: node.offset, length: 1 },
+						location: { offset: node.offset, length: node.length },
 						message: l10n.t('Missing property "{0}".', propertyName)
 					});
 				}

src/services/jsonSchemaService.ts

@@ -535,6 +535,37 @@ export class JSONSchemaService implements IJSONSchemaService {
 			return current;
 		};
 
+		// Like findSectionByJSONPointer, but also tracks the effective base URI
+		// through any $id encountered along the path. This is needed so that
+		// $ref values merged from the found section can be resolved against the
+		// correct base, not the document root.
+		const findSectionAndBase = (schema: JSONSchema, path: string, baseHandle: SchemaHandle): { section: any; baseHandle: SchemaHandle } => {
+			path = decodeURIComponent(path);
+			let current: any = schema;
+			let currentBaseHandle = baseHandle;
+			if (path[0] === '/') {
+				path = path.substring(1);
+			}
+			path.split('/').some((part) => {
+				part = part.replace(/~1/g, '/').replace(/~0/g, '~');
+				current = current[part];
+				if (!current) {
+					return true;
+				}
+				const id = getSchemaId(current);
+				if (isString(id) && id.charAt(0) !== '#') {
+					let resolvedUri = id;
+					if (contextService && !/^[A-Za-z][A-Za-z0-9+\-.+]*:\/.*/.test(id)) {
+						resolvedUri = contextService.resolveRelativePath(id, currentBaseHandle.uri);
+					}
+					resolvedUri = normalizeId(resolvedUri);
+					currentBaseHandle = this.getOrAddSchemaHandle(resolvedUri);
+				}
+				return false;
+			});
+			return { section: current, baseHandle: currentBaseHandle };
+		};
+
 		const findSchemaById = (schema: JSONSchema, handle: SchemaHandle, id: string) => {
 			if (!handle.anchors) {
 				handle.anchors = collectAnchors(schema);
@@ -584,16 +615,29 @@ export class JSONSchemaService implements IJSONSchemaService {
 
 		const mergeRef = (target: JSONSchema, sourceRoot: JSONSchema, sourceHandle: SchemaHandle, refSegment: string | undefined): void => {
 			let section;
+			let sectionBaseHandle = sourceHandle;
 			if (refSegment === undefined || refSegment.length === 0) {
 				section = sourceRoot;
 			} else if (refSegment.charAt(0) === '/') {
 				// A $ref to a JSON Pointer (i.e #/definitions/foo)
-				section = findSectionByJSONPointer(sourceRoot, refSegment);
+				// Track $id base changes along the path so inner $refs resolve correctly.
+				({ section, baseHandle: sectionBaseHandle } = findSectionAndBase(sourceRoot, refSegment, sourceHandle));
 			} else {
 				// A $ref to a sub-schema with an $id (i.e #hello)
 				section = findSchemaById(sourceRoot, sourceHandle, refSegment);
 			}
 			if (section) {
+				// If the found section contains a $ref that needs to be resolved
+				// relative to a different base (e.g. it's inside a schema with $id),
+				// pre-resolve it now so it carries the correct base URI context.
+				if (section.$ref && sectionBaseHandle !== sourceHandle) {
+					const innerRef = section.$ref;
+					const innerSegments = innerRef.split('#', 2);
+					if (innerSegments[0].length > 0 && contextService && !/^[A-Za-z][A-Za-z0-9+\-.+]*:\/.*/.test(innerSegments[0])) {
+						section.$ref = contextService.resolveRelativePath(innerSegments[0], sectionBaseHandle.uri) +
+							(innerSegments[1] !== undefined ? '#' + innerSegments[1] : '');
+					}
+				}
 				const reservedKeys = new Set(['$ref', '$defs', 'definitions', '$schema', '$id', 'id']);
 
 				// In JSON Schema draft-04 through draft-07, $ref completely overrides any sibling keywords.
@@ -696,10 +740,12 @@ export class JSONSchemaService implements IJSONSchemaService {
 					delete schema.$ref;
 					if (segments[0].length > 0) {
 						// This is a reference to an external schema (like "foo.json" or "foo.json#/bar")
-						// According to JSON Schema spec, $ref is resolved against the parent's base URI,
-						// not against a sibling $id at the same level
-						// So we use currentBaseHandle (parent's), not newBaseHandle (which might include sibling $id)
-						openPromises.push(resolveExternalLink(schema, segments[0], segments[1], currentBaseHandle));
+						// Per JSON Schema spec, $ref is resolved against the current base URI.
+						// If this schema has its own $id (sibling case), the $ref should resolve
+						// against the parent's base, not the sibling $id. Otherwise, use the
+						// nearest ancestor's base (newBaseHandle).
+						const refBase = (newBase === schema) ? currentBaseHandle : newBaseHandle;
+						openPromises.push(resolveExternalLink(schema, segments[0], segments[1], refBase));
 						return;
 					} else {
 						// This is an internal reference (like "#/definitions/foo")
@@ -748,8 +794,8 @@ export class JSONSchemaService implements IJSONSchemaService {
 
 				// Collect anchor from this node
 				// In draft-04/06/07, anchors are defined via $id/#fragment (e.g., "$id": "#myanchor")
-				// $anchor was introduced in draft-2019-09, so only use it for 2019-09 and later
-				const fragmentAnchor = isString(id) && id.charAt(0) === '#' ? id.substring(1) : undefined;
+				// In 2019-09+, $id fragments are no longer anchors; $anchor is used instead
+				const fragmentAnchor = (schemaDraft === undefined || schemaDraft < SchemaDraft.v2019_09) && isString(id) && id.charAt(0) === '#' ? id.substring(1) : undefined;
 				const dollarAnchor = (schemaDraft === undefined || schemaDraft >= SchemaDraft.v2019_09) ? node.$anchor : undefined;
 				const anchor = fragmentAnchor ?? dollarAnchor;
 				if (anchor) {

src/services/vocabularies.ts

@@ -3,6 +3,8 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
+import { SchemaDraft } from '../jsonLanguageTypes';
+
 /*
  * Checks if a keyword is enabled based on the active vocabularies.
  * If no vocabulary constraints are present, all keywords are enabled.
@@ -108,35 +110,43 @@ export function isKeywordEnabled(
  * - format-assertion: format must be validated and can produce errors
  * 
  * For backwards compatibility:
- * - If no vocabularies are specified, format asserts (pre-2019-09 behavior)
+ * - If no vocabularies are specified and no explicit 2019-09+ draft, format asserts
  * - 2019-09 format vocabulary is annotation-only
  * - 2020-12 format-assertion vocabulary asserts
  * - 2020-12 format-annotation vocabulary does not assert
  * 
  * @param activeVocabularies Map of active vocabulary URIs to required flag, or undefined if no constraints
+ * @param schemaDraft The explicitly declared schema draft (only set when $schema was present), or undefined
  * @returns true if format validation should produce errors, false if annotation-only
  */
-export function isFormatAssertionEnabled(activeVocabularies?: Map<string, boolean>): boolean {
-	// If no vocabulary constraints or empty vocabulary map, assert for backward compatibility with older schemas
-	if (!activeVocabularies || activeVocabularies.size === 0) {
-		return true;
-	}
+export function isFormatAssertionEnabled(activeVocabularies?: Map<string, boolean>, schemaDraft?: SchemaDraft): boolean {
+	// If vocabulary constraints are present, use them to determine format assertion
+	if (activeVocabularies && activeVocabularies.size > 0) {
+		// 2020-12 format-assertion explicitly enables format validation errors
+		if (activeVocabularies.has('https://json-schema.org/draft/2020-12/vocab/format-assertion')) {
+			return true;
+		}
 
-	// 2020-12 format-assertion explicitly enables format validation errors
-	if (activeVocabularies.has('https://json-schema.org/draft/2020-12/vocab/format-assertion')) {
-		return true;
-	}
+		// 2019-09 format vocabulary is annotation-only per spec
+		if (activeVocabularies.has('https://json-schema.org/draft/2019-09/vocab/format')) {
+			return false;
+		}
 
-	// 2019-09 format vocabulary is annotation-only per spec
-	if (activeVocabularies.has('https://json-schema.org/draft/2019-09/vocab/format')) {
+		// 2020-12 format-annotation is annotation-only, no assertion
+		if (activeVocabularies.has('https://json-schema.org/draft/2020-12/vocab/format-annotation')) {
+			return false;
+		}
+
+		// No format vocabulary active - no assertion
 		return false;
 	}
 
-	// 2020-12 format-annotation is annotation-only, no assertion
-	if (activeVocabularies.has('https://json-schema.org/draft/2020-12/vocab/format-annotation')) {
+	// No vocabulary constraints:
+	// For explicitly declared 2019-09+ schemas, format is annotation-only by default per spec.
+	// For older drafts or no explicit $schema, format asserts for backward compatibility.
+	if (schemaDraft !== undefined && schemaDraft >= SchemaDraft.v2019_09) {
 		return false;
 	}
 
-	// No format vocabulary active - no assertion
-	return false;
+	return true;
 }