Add vocabulary tracking and format assertion support for JSON Schema 2019-09

- Change Vocabularies type from Set to Map to track required/optional status
- Add isFormatAssertionEnabled for format-annotation vs format-assertion
- Handle $ref sibling keywords correctly per draft version
- Only recognize $anchor in draft-2019-09 and later schemas
- Fix dependencies keyword to only apply in draft-07 and earlier
- Fix missing property error location to use object offset

Author: Keegan Caruso

src/jsonLanguageTypes.ts

@@ -39,11 +39,13 @@ export {
 };
 
 /**
- * Represents a set of active JSON Schema vocabularies.
- * Used to filter which keywords are processed during validation based on the metaschema's $vocabulary declaration.
+ * Represents active JSON Schema vocabularies with their required/optional status.
+ * Key = vocabulary URI, Value = true if required, false if optional.
+ * Both required and optional vocabularies are active; the boolean indicates
+ * whether the validator must understand it (true) or should understand it (false).
  * @since 2019-09
  */
-export type Vocabularies = Set<string>;
+export type Vocabularies = Map<string, boolean>;
 
 /**
  * Error codes used by diagnostics

src/parser/jsonParser.ts

@@ -9,7 +9,7 @@ import { isNumber, equals, isBoolean, isString, isDefined, isObject } from '../u
 import { extendedRegExp, stringLength } from '../utils/strings';
 import { TextDocument, ASTNode, ObjectASTNode, ArrayASTNode, BooleanASTNode, NumberASTNode, StringASTNode, NullASTNode, PropertyASTNode, JSONPath, ErrorCode, Diagnostic, DiagnosticSeverity, Range, SchemaDraft, Vocabularies } from '../jsonLanguageTypes';
 import { URI } from 'vscode-uri';
-import { isKeywordEnabled } from '../services/vocabularies';
+import { isKeywordEnabled, isFormatAssertionEnabled } from '../services/vocabularies';
 
 import * as l10n from '@vscode/l10n';
 
@@ -454,7 +454,16 @@ function validate(n: ASTNode | undefined, schema: JSONSchema, validationResult:
 	// Push current schema to stack for $recursiveRef resolution
 	schemaStack.push(schema);
 
-	const enabled = (keyword: string) => isKeywordEnabled(keyword, context.activeVocabularies);
+	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')
+		{
+			return context.schemaDraft <= SchemaDraft.v7;
+		}
+			
+		return isKeywordEnabled(keyword, context.activeVocabularies);
+	};
 
 	_validateNode();
 
@@ -849,7 +858,8 @@ function validate(n: ASTNode | undefined, schema: JSONSchema, validationResult:
 			}
 		}
 
-		if (schema.format && enabled('format')) {
+		// Only validate format if format-assertion vocabulary is active (not annotation-only)
+		if (schema.format && enabled('format') && isFormatAssertionEnabled(context.activeVocabularies)) {
 			switch (schema.format) {
 				case 'uri':
 				case 'uri-reference': {
@@ -1044,10 +1054,8 @@ function validate(n: ASTNode | undefined, schema: JSONSchema, validationResult:
 		if (Array.isArray(schema.required) && enabled('required')) {
 			for (const propertyName of schema.required) {
 				if (!seenKeys[propertyName]) {
-					const keyNode = node.parent && node.parent.type === 'property' && node.parent.keyNode;
-					const location = keyNode ? { offset: keyNode.offset, length: keyNode.length } : { offset: node.offset, length: 1 };
 					validationResult.problems.push({
-						location: location,
+						location: { offset: node.offset, length: 1 },
 						message: l10n.t('Missing property "{0}".', propertyName)
 					});
 				}

src/services/jsonSchemaService.ts

@@ -177,6 +177,12 @@ class SchemaHandle implements ISchemaHandle {
 		this.anchors = undefined;
 		return hasChanges;
 	}
+
+	public setSchemaContent(schemaContent: JSONSchema): void {
+		this.unresolvedSchema = this.service.promise.resolve(new UnresolvedSchema(schemaContent));
+		this.resolvedSchema = undefined;
+		this.anchors = undefined;
+	}
 }
 
 
@@ -503,11 +509,12 @@ export class JSONSchemaService implements IJSONSchemaService {
 			if (!metaschema.$vocabulary || typeof metaschema.$vocabulary !== 'object') {
 				return undefined;
 			}
-			const vocabs = new Set<string>();
+			// Both true and false values indicate the vocabulary is active.
+			// The boolean indicates whether the vocabulary is required (true) or optional (false),
+			// not whether it's in use. All listed vocabularies should be included.
+			const vocabs = new Map<string, boolean>();
 			for (const [uri, required] of Object.entries(metaschema.$vocabulary)) {
-				if (required === true) {
-					vocabs.add(uri);
-				}
+				vocabs.set(uri, required);
 			}
 			return vocabs.size > 0 ? vocabs : undefined;
 		};
@@ -587,13 +594,25 @@ export class JSONSchemaService implements IJSONSchemaService {
 				section = findSchemaById(sourceRoot, sourceHandle, refSegment);
 			}
 			if (section) {
-				// In JSON Schema 2019-09 or greater, $ref creates a new scope when it has sibling keywords.
-				// When the $ref'd schema has unevaluatedProperties/unevaluatedItems, it should not
-				// see properties/items evaluated by sibling keywords.
-				// To achieve this, we wrap the $ref in an allOf when needed.
-				if (needsScopeIsolation(section, target)) {
-					// Extract sibling keywords into a separate schema
-					const reservedKeys = new Set(['$ref', '$defs', 'definitions', '$schema', '$id', 'id']);
+				const reservedKeys = new Set(['$ref', '$defs', 'definitions', '$schema', '$id', 'id']);
+
+				// In JSON Schema draft-04 through draft-07, $ref completely overrides any sibling keywords.
+				// Starting in 2019-09, sibling keywords are processed alongside $ref.
+				// Only strip siblings when schema explicitly declares a pre-2019-09 draft via $schema.
+				const isPreDraft201909 = schemaDraft !== undefined && schemaDraft < SchemaDraft.v2019_09;
+				if (isPreDraft201909) {
+					// Clear all sibling keywords from target - $ref takes precedence
+					for (const key in target) {
+						if (target.hasOwnProperty(key) && !reservedKeys.has(key)) {
+							delete (target as any)[key];
+						}
+					}
+					merge(target, section);
+				} else if (needsScopeIsolation(section, target)) {
+					// In JSON Schema 2019-09 or greater, $ref creates a new scope when it has sibling keywords.
+					// When the $ref'd schema has unevaluatedProperties/unevaluatedItems, it should not
+					// see properties/items evaluated by sibling keywords.
+					// To achieve this, we wrap the $ref in an allOf when needed.
 					const siblingSchema: JSONSchema = {};
 					const refSchema = { ...section };
 
@@ -728,7 +747,11 @@ export class JSONSchemaService implements IJSONSchemaService {
 				}
 
 				// Collect anchor from this node
-				const anchor = isString(id) && id.charAt(0) === '#' ? id.substring(1) : node.$anchor;
+				// 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;
+				const dollarAnchor = (schemaDraft === undefined || schemaDraft >= SchemaDraft.v2019_09) ? node.$anchor : undefined;
+				const anchor = fragmentAnchor ?? dollarAnchor;
 				if (anchor) {
 					if (result.has(anchor)) {
 						resolveErrors.push(toDiagnostic(l10n.t('Duplicate anchor declaration: \'{0}\'', anchor), ErrorCode.SchemaResolveError));
@@ -771,8 +794,13 @@ export class JSONSchemaService implements IJSONSchemaService {
 				let newBaseUri = currentBaseUri;
 				if (isString(id) && id.charAt(0) !== '#') {
 					const resolvedUri = resolveId(id, currentBaseUri);
-					if (!this.schemasById[resolvedUri]) {
+					const existingHandle = this.schemasById[resolvedUri];
+					if (!existingHandle) {
 						this.addSchemaHandle(resolvedUri, node);
+					} else {
+						// Update existing handle with embedded schema content
+						// This ensures embedded schemas take precedence over external schemas
+						existingHandle.setSchemaContent(node);
 					}
 					newBaseUri = resolvedUri;
 				}
@@ -803,7 +831,7 @@ export class JSONSchemaService implements IJSONSchemaService {
 				// Only extract vocabularies if the meta-schema has a $vocabulary property
 				// or if it's draft 2019-09 or later which support vocabularies.
 				const metaschemaDraft = unresolvedMetaschema.schema.$schema ? getSchemaDraftFromId(unresolvedMetaschema.schema.$schema) : undefined;
-				const isDraft2019OrLater = metaschemaDraft === SchemaDraft.v2019_09 || metaschemaDraft === SchemaDraft.v2020_12;
+				const isDraft2019OrLater = metaschemaDraft && metaschemaDraft >= SchemaDraft.v2019_09;
 				const hasVocabulary = unresolvedMetaschema.schema.$vocabulary && typeof unresolvedMetaschema.schema.$vocabulary === 'object';
 
 				if (hasVocabulary || isDraft2019OrLater) {

src/services/vocabularies.ts

@@ -3,7 +3,7 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-/**
+/*
  * Checks if a keyword is enabled based on the active vocabularies.
  * If no vocabulary constraints are present, all keywords are enabled.
  * Core keywords are always enabled regardless of vocabulary settings.
@@ -14,7 +14,7 @@
  */
 export function isKeywordEnabled(
 	keyword: string,
-	activeVocabularies?: Set<string>
+	activeVocabularies?: Map<string, boolean>
 ): boolean {
 	const vocabularyKeywords: { [uri: string]: string[] } = {
 		'https://json-schema.org/draft/2019-09/vocab/core': [
@@ -75,7 +75,6 @@ export function isKeywordEnabled(
 		]
 	};
 
-
 	// If no vocabulary constraints, treat all keywords as enabled
 	if (!activeVocabularies) {
 		return true;
@@ -100,3 +99,44 @@ export function isKeywordEnabled(
 	// Keyword not found in any vocabulary - disable it
 	return false;
 }
+
+/*
+ * Checks if format validation should produce assertion errors.
+ * 
+ * According to JSON Schema 2020-12:
+ * - format-annotation: format is purely informational, no validation errors
+ * - format-assertion: format must be validated and can produce errors
+ * 
+ * For backwards compatibility:
+ * - If no vocabularies are specified, format asserts (pre-2019-09 behavior)
+ * - 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
+ * @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;
+	}
+
+	// 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;
+	}
+
+	// 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;
+}