You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@daffodil.apache.org by rs...@apache.org on 2025/11/06 14:16:56 UTC
(daffodil-vscode) branch main updated: Document IntelliSense AttributeCompletionProvider + AttributeValueCompletionProvider + relevant files
This is an automated email from the ASF dual-hosted git repository.
rstrickland pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/daffodil-vscode.git
The following commit(s) were added to refs/heads/main by this push:
new 0b15bc7 Document IntelliSense AttributeCompletionProvider + AttributeValueCompletionProvider + relevant files
0b15bc7 is described below
commit 0b15bc77fddc42efa991f57c62c6cd8bc2c7eab4
Author: Jeremy Yao <je...@nteligen.com>
AuthorDate: Sat Nov 1 19:20:07 2025 -0400
Document IntelliSense AttributeCompletionProvider + AttributeValueCompletionProvider + relevant files
Closes #1490
Closes #1489
---
src/language/intellisense-development.md | 245 ++++++++++++++++++
src/language/providers/attributeCompletion.ts | 141 ++++++++++-
src/language/providers/attributeValueCompletion.ts | 85 +++++++
.../providers/intellisense/attributeItems.ts | 280 ++++++++++++++++-----
.../providers/intellisense/attributeValueItems.ts | 11 +
5 files changed, 685 insertions(+), 77 deletions(-)
diff --git a/src/language/intellisense-development.md b/src/language/intellisense-development.md
new file mode 100644
index 0000000..bd27782
--- /dev/null
+++ b/src/language/intellisense-development.md
@@ -0,0 +1,245 @@
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+ contributor license agreements. See the NOTICE file distributed with
+ this work for additional information regarding copyright ownership.
+ The ASF licenses this file to You under the Apache License, Version 2.0
+ (the "License"); you may not use this file except in compliance with
+ the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-->
+
+# Intellisense
+
+This document contains an overview of how intellisense works as well as a general view of the architecture of the code.
+
+## Table of Contents
+
+- [Intellisense](#intellisense)
+ - [Table of Contents](#table-of-contents)
+ - [General Intellisense Concepts](#general-intellisense-concepts)
+ - [Providers](#providers)
+ - [Registration](#registration)
+ - [DFDL](#dfdl)
+ - [High-level dfdl Intellisense Overview](#high-level-dfdl-intellisense-overview)
+ - [Provider Registration (Start Here)](#provider-registration-start-here)
+ - [Provider Implementation Locations](#provider-implementation-locations)
+ - [Helpers + Vocabulary](#helpers-vocabulary)
+ - [Context Parsing](#context-parsing)
+ - [Namespace / Prefix Handling](#namespace-prefix-handling)
+ - [Completions Construction](#completions-construction)
+ - [Hover / Documentation](#hover-documentation)
+ - [Testing](#testing)
+ - [Individual File Deep-Dives](#individual-file-deep-dives)
+ - [Core Provider Files](#core-provider-files)
+ - [attributeCompletion.ts](#attributecompletionts)
+ - [attributeValueCompletion.ts](#attributevaluecompletionts)
+ - [Intellisense Data Files (intellisense subdirectory)](#intellisense-data-files-intellisense-subdirectory)
+ - [attributeItems.ts](#attributeitemsts)
+ - [attributeValueItems.ts](#attributevalueitemsts)
+ - [TDML](#tdml)
+
+### General Intellisense Concepts
+
+#### Providers
+
+Providers in the VS Code API are extension points that let you plug specific language or editor features into the editor’s pipeline (e.g., completions, hovers, formatting). Proviers are implemented and then registered in the code which gets then gets called depending on the situation the provider activates.
+
+Many providers exist. Relevant ones that are used extensively in the code pertaining to IntelliSense functionality include `completionItemProvider` which provide code suggestions and `hoverProvider` which provider hover information. More information can be found at <https://code.visualstudio.com/api/references/vscode-api>.
+
+#### Registration
+
+After a provider has its functionality implemented, it can then be registered into the extension so that its functionality can be utilized in the IntelliSense functionality pipeline. Relevant registration calls include `registerCompletionItemProvider` and `registerHoverProvider`.
+
+### DFDL
+
+This section focuses on the `dfdl` Intellisense implementation.
+
+#### High-level dfdl Intellisense Overview
+
+This section providers a high-level view of the architecture of all relevant code items pertaining to the `dfdl` IntelliSense functionality.
+
+##### Provider Registration (Start Here)
+
+`src/language/dfdl.ts` is the starting point. It wires up the extension’s language features by calling VS Code registration APIs (e.g., `registerCompletionItemProvider`, `registerHoverProvider`, and similar) that are then customized as functions that provide customized provider functinoality.
+
+In other words, `dfdl.ts` connects the provider implementations to VS Code for the DFDL language.
+
+##### Provider Implementation Locations
+
+Autocompletion logic is split into multiple provider modules under `src/language/providers/`, each handling different completion scenarios.
+
+- `elementCompletion.ts` -- suggests child elements / element tags.
+- `attributeCompletion.ts` -- suggests attribute names when inside an element.
+- `attributeValueCompletion.ts` -- provides completion suggestions for attribute values (e.g., enumerated values).
+- `closeElement.ts`, `closeElementSlash.ts` -- completions for closing tags and slash completions.
+- `attributeHover.ts` -- hover provider that shows attribute documentation/available attributes.
+
+It should be noted that there are many `registerCompletionItemProvider` calls. The implemented `completionItemProvider`s each contain logic to determine whether or not it the provider is relevant to a given situation or not.
+
+##### Helpers + Vocabulary
+
+`src/language/providers/utils.ts` and `src/language/providers/intellisense/commonItems.ts` contain shared helpers for constructing CompletionItem objects, and context parsing utilities used by many providers. For `src/language/providers/intellisense/commonItems.ts` and tracing through usage, it's used by `attributeCompletion.ts` and `elementCompletion.ts`.
+
+`src/rootCompletion/utils.ts` contains utilities used for root-level completion logic (common completion primitives).
+
+The code relies on project classes like schemaData (found under src/classes/schemaData.ts) and other "model" classes to know DFDL vocabulary (elements, attributes, properties). Those model classes hold the authoritative lists that the providers consult when building suggestions.
+
+##### Context Parsing
+
+Providers do lightweight parsing of the current document and cursor context (often using a small tokenizer / utility functions) to determine whether the cursor is:
+
+- inside an element start tag
+- inside attribute name or value
+- within namespace/prefix context
+- in text content (no suggestions)
+
+This context detection guides which provider runs and how it filters suggestions.
+
+##### Namespace / Prefix Handling
+
+The code is able to determine the current element's namespace and the suggestions are able to insert the correct namespace or omit the namespace accordinly for attribute and element suggestions
+
+##### Completions Construction
+
+Providers build `vscode.CompletionItem` objects populated with:
+
+- label, kind (element/attribute/snippet)
+- insertText (text inserted when the user accepts the suggestion)
+- sometimes additionalTextEdits or textEdit ranges to precisely replace text
+- optional documentation or detail shown in the completion UI
+
+Some items use resolveCompletionItem logic if additional data must be computed after selection.
+
+##### Hover / Documentation
+
+`attributeHover.ts` forms hover messages (Markdown strings) describing attributes available on a tag, DFDL property documentation, etc. Hover resolves current element context then gathers attribute docs and returns a `vscode.Hover` object.
+
+Hover tooltips can be found under `attributeHoverValues()` in `attributeHoverItems.ts`.
+
+##### Testing
+
+`src/tests/suite/language/items.test.ts` contains unit-style checks that assert which items should be available in certain contexts -- useful to confirm the expected behavior of completion providers.
+
+#### Individual File Deep-Dives
+
+##### Core Provider Files
+
+###### attributeCompletion.ts
+
+**Purpose:** Attribute name completion provider for XML elements in DFDL schemas and TDML test files.
+
+**Key Functionality:**
+
+- Provides context-aware attribute suggestions based on current XML element type
+- Suggests valid DFDL attributes for DFDL-specific elements
+- Suggests XSD attributes for XML Schema elements
+- Filters out already-present attributes to avoid duplicates
+- Handles both space-triggered and newline-triggered completion
+- Scans document for user-defined types for type attribute completion
+
+**Key Functions:**
+
+- `getAttributeCompletionProvider()`: DFDL document provider
+- `getTDMLAttributeCompletionProvider()`: TDML document provider
+- `getDefinedTypes()`: Scans for xs:simpleType and xs:complexType declarations
+- `prunedDuplicateAttributes()`: Removes attributes already present on element
+
+**Trigger:** Space (` `) or newline (`\n`)
+
+###### attributeValueCompletion.ts
+
+**Purpose:** Attribute value completion provider for DFDL schemas and TDML test files.
+
+**Key Functionality:**
+
+- Intelligent value suggestions based on attribute name
+- Enumerated value completion for DFDL properties with fixed value sets
+- Type name completion (references to xs:simpleType or xs:complexType)
+- Variable name completion (references to dfdl:defineVariable)
+- Boolean values (true/false, yes/no) for boolean attributes
+- Standard values (encoding names, byte orders, etc.)
+
+**Key Functions:**
+
+- `getAttributeValueCompletionProvider()`: DFDL document provider
+- `getTDMLAttributeValueCompletionProvider()`: TDML document provider
+- `getAttributeDetails()`: Extracts attribute name and value range for completion context
+
+**Trigger:** Space (` `)
+
+##### Intellisense Data Files (intellisense subdirectory)
+
+###### attributeItems.ts
+
+**Purpose:** Static completion data for XML schema attributes used in DFDL/XSD documents.
+
+**Data Structure:**
+
+- Array of completion items, each containing:
+ - `item`: Attribute name
+ - `snippetString`: VS Code snippet with placeholders and default values
+ - `markdownString`: Documentation shown in completion tooltip
+
+**Snippet Features:**
+
+- Tab stops ($1, $2, etc.)
+- Choice placeholders (${1|option1,option2|})
+- Final cursor position ($0)
+- Namespace prefix handling
+
+**Attribute Categories:**
+
+- XSD Core Attributes (name, ref, type, minOccurs, maxOccurs)
+- DFDL Length Properties (dfdl:length, dfdl:lengthKind, dfdl:lengthUnits)
+- DFDL Encoding Properties (dfdl:encoding, dfdl:encodingErrorPolicy)
+- DFDL Text/Binary Representation
+- DFDL Separators/Delimiters
+- DFDL Calendar/Date
+- DFDL Escape Schemes
+- DFDL Assertions
+
+**Key Export:**
+
+- `attributeCompletion(additionalItems, nsPrefix, dfdlPrefix, spacingChar, afterChar)`: Returns object with completion items
+
+###### attributeValueItems.ts
+
+**Purpose:** Completion logic for attribute values (as opposed to attribute names).
+
+**Data Structures:**
+
+- `noChoiceAttributes`: Array of free-text attributes that should not show completion choices
+- `attributeValues()`: Function that generates value snippets based on attribute name
+
+**Snippet Patterns:**
+
+- `${1|option1,option2|}`: Dropdown with predefined choices
+- `"$1"`: Simple placeholder for user input
+- `"{$1}"`: Placeholder for DFDL expressions with curly braces
+- `$0`: Final cursor position
+
+**Attribute Categories Handled:**
+
+- Occurrence attributes (minOccurs, maxOccurs, occursCountKind)
+- Length attributes (lengthKind, lengthUnits)
+- Encoding attributes (encoding, encodingErrorPolicy)
+- Binary/Text format attributes
+- Calendar/date attributes
+- Sequence/Choice properties
+- Yes/No boolean properties
+
+**Key Exports:**
+
+- `noChoiceAttributes`: List of attributes without predefined choices
+- `attributeValues(attributeName, startPos, additionalTypes)`: Inserts appropriate snippet at cursor
+
+### TDML
+
+This section focuses on the `tdml` Intellisense implementation. It should be noted that the functionality is currently unused.
diff --git a/src/language/providers/attributeCompletion.ts b/src/language/providers/attributeCompletion.ts
index 6cc1b1f..b94d68f 100644
--- a/src/language/providers/attributeCompletion.ts
+++ b/src/language/providers/attributeCompletion.ts
@@ -15,6 +15,27 @@
* limitations under the License.
*/
+/**
+ * Attribute Completion Provider for DFDL and TDML Documents
+ *
+ * This module provides intelligent attribute name completion for XML elements in DFDL schemas
+ * and TDML test files. It offers context-aware suggestions based on:
+ * - The current XML element type (xs:element, xs:sequence, dfdl:format, etc.)
+ * - The namespace being used (XSD, DFDL, TDML)
+ * - Previously entered attributes (to avoid suggesting duplicates)
+ * - The cursor position within the element tag
+ *
+ * Features:
+ * - Suggests valid DFDL attributes for DFDL-specific elements
+ * - Suggests XSD attributes for XML Schema elements
+ * - Suggests TDML attributes for TDML test elements
+ * - Filters out already-present attributes to avoid duplicates
+ * - Handles both space-triggered and equals-triggered completion
+ * - Provides appropriate snippets with placeholders for attribute values
+ *
+ * The provider is triggered when the user types ' ' (space) or '=' within an XML element tag.
+ */
+
import * as vscode from 'vscode'
import { xml2js } from 'xml-js'
import {
@@ -34,6 +55,19 @@ import {
import { attributeCompletion } from './intellisense/attributeItems'
+/**
+ * Builds a list of completion items for attributes based on the element context.
+ * Combines common items with element-specific attribute suggestions from the intellisense data.
+ *
+ * @param itemsToUse - Array of attribute names that are valid for the current element
+ * @param preVal - Prefix value to prepend to completion text
+ * @param additionalItems - The element name for which to get attribute suggestions
+ * @param nsPrefix - The XML Schema namespace prefix (e.g., 'xs:', 'xsd:')
+ * @param dfdlPrefix - The DFDL namespace prefix (typically 'dfdl:')
+ * @param spacingChar - Character for spacing in the completion snippet
+ * @param afterChar - Character to insert after the attribute value
+ * @returns Array of VS Code completion items for attributes
+ */
function getCompletionItems(
itemsToUse: string[],
preVal: string = '',
@@ -43,8 +77,10 @@ function getCompletionItems(
spacingChar: string,
afterChar: string
) {
+ // array for completion item that will be returned
let compItems: vscode.CompletionItem[] = []
+ // Add element-specific attribute completion items from intellisense data
attributeCompletion(
additionalItems,
nsPrefix,
@@ -61,36 +97,45 @@ function getCompletionItems(
return compItems
}
-/** Retrieves relevant lines of the document for use in prunedDuplicateAttributes
- * Format of return is as follows [relevant parts of the string, index representing the location of the cursor in the string]
+/**
+ * Retrieves the relevant text of the current XML element for attribute parsing.
+ * Extracts the portion of the document that contains the element tag being edited,
+ * which may span multiple lines. This text is used to identify existing attributes
+ * and determine what new attributes can be suggested.
*
- * @param position
- * @param document
- * @returns
+ * The function searches backwards to find the opening '<' of the element and forwards
+ * to find where the element ends (either '>' or '/>').
+ *
+ * @param position - The current cursor position
+ * @param document - The VS Code text document
+ * @returns A tuple of [element text, cursor index within that text]
*/
-
function getPotentialAttributeText(
position: vscode.Position,
document: vscode.TextDocument
): [string, number] {
- // Overall strategy: Find the lines that are relevant to the XML element we're looking at. The element can be incomplete and not closed.
+ // Overall strategy: Find the lines that are relevant to the XML element we're looking at.
+ // The element can be incomplete and not yet closed.
let lowerLineBound: number = position.line
let upperLineBound: number = position.line
- // Determining the lowerbound strategy: Traverse backwards line-by-line until we encounter an opening character (<)
+ // Determining the lower bound strategy: Traverse backwards line-by-line until we encounter
+ // an opening character (<), which marks the start of the current element.
- //handle edge case if there's an element closing on the same line or if there is a closing tag after the cursor on the same line
+ // Handle edge case if there's an element closing on the same line or if there is a
+ // closing tag after the cursor on the same line
if (lowerLineBound > 0) {
lowerLineBound--
}
while (
lowerLineBound > 0 && // Make sure we aren't going to negative line indexes
- document.lineAt(lowerLineBound).text.indexOf('<') == -1 // continue going up the document if there is no <
+ document.lineAt(lowerLineBound).text.indexOf('<') == -1 // Continue going up if no '<' found
) {
- lowerLineBound-- // traverse backwards via decrementing line index
+ lowerLineBound-- // Traverse backwards via decrementing line index
}
- // Upperbound strategy: Increment the upperLineBound 1 line downward to avoid the edge case it's equal to the lowerLineBound and there's more content beyond lowerLineBound
+ // Upper bound strategy: Increment the upperLineBound 1 line downward to avoid the edge case
+ // where it's equal to the lowerLineBound and there's more content beyond lowerLineBound
if (upperLineBound != document.lineCount - 1) {
upperLineBound++
}
@@ -205,6 +250,20 @@ function prunedDuplicateAttributes(
return originalAttributeSuggestions
}
+/**
+ * Registers the attribute completion provider for DFDL documents.
+ * This provider suggests valid attribute names when the user types within an XML element tag.
+ *
+ * The provider:
+ * 1. Determines the current element context (which element the cursor is inside)
+ * 2. Gets the list of valid attributes for that element
+ * 3. Filters out attributes that are already present
+ * 4. Returns context-appropriate attribute suggestions
+ *
+ * Triggered by: space (' ') and newline ('\n') characters
+ *
+ * @returns A VS Code Disposable for the registered completion provider
+ */
export function getAttributeCompletionProvider() {
return vscode.languages.registerCompletionItemProvider(
{ language: 'dfdl' },
@@ -271,6 +330,15 @@ export function getAttributeCompletionProvider() {
)
}
+/**
+ * Registers the attribute completion provider for TDML test documents.
+ * Similar to the DFDL provider but tailored for TDML-specific attributes
+ * like test types, validation modes, and TDML configuration options.
+ *
+ * Triggered by: space (' ') and newline ('\n') characters
+ *
+ * @returns A VS Code Disposable for the registered completion provider
+ */
export function getTDMLAttributeCompletionProvider() {
return vscode.languages.registerCompletionItemProvider(
{ language: 'tdml' },
@@ -327,6 +395,18 @@ export function getTDMLAttributeCompletionProvider() {
)
}
+/**
+ * Scans the entire document to find all user-defined type names.
+ * Searches for xs:simpleType and xs:complexType declarations and extracts
+ * their names, which can then be used for type attribute completion.
+ *
+ * This allows users to get completion suggestions for their custom-defined
+ * types when specifying the 'type' attribute on elements.
+ *
+ * @param document - The VS Code text document to scan
+ * @param nsPrefix - The namespace prefix for schema elements (e.g., 'xs:')
+ * @returns Comma-separated string of defined type names
+ */
export function getDefinedTypes(
document: vscode.TextDocument,
nsPrefix: string
@@ -357,6 +437,29 @@ export function getDefinedTypes(
return additionalTypes
}
+/**
+ * Determines which completion items to show based on the nearest open element.
+ * Matches the element name against known DFDL elements and returns appropriate
+ * attribute suggestions for that element type.
+ *
+ * The function handles special cases for different element types:
+ * - Schema root elements
+ * - Element declarations
+ * - Sequence/choice/group definitions
+ * - Format definitions
+ * - Variables and assertions
+ * - TDML test case elements
+ *
+ * @param nearestOpenItem - The name of the current enclosing element
+ * @param attributeNames - Array of attributes already present on the element
+ * @param triggerText - The text of the current line up to the cursor
+ * @param nsPrefix - The namespace prefix being used
+ * @param preVal - Prefix value to add before attribute (for formatting)
+ * @param additionalItems - String of additional items (types/variables) to include
+ * @param charBeforeTrigger - Character immediately before the cursor
+ * @param charAfterTrigger - Character immediately after the cursor
+ * @returns Array of completion items appropriate for the element, or undefined
+ */
function checkNearestOpenItem(
nearestOpenItem: string,
attributeNames: string[],
@@ -748,6 +851,20 @@ function checkNearestOpenItem(
}
}
+/**
+ * Creates completion items specifically for dfdl:defineVariable elements.
+ * Provides attribute suggestions for variable declarations including:
+ * - external: Whether the variable is externally provided
+ * - defaultValue: Default value for the variable
+ * - type: Data type of the variable (with custom type suggestions)
+ *
+ * @param preVal - Prefix value for formatting
+ * @param additionalItems - Comma-separated list of user-defined types
+ * @param nsPrefix - The namespace prefix
+ * @param spacingChar - Character for spacing before the attribute
+ * @param afterChar - Character to insert after the attribute value
+ * @returns Array of completion items for defineVariable attributes
+ */
function getDefineVariableCompletionItems(
preVal: string,
additionalItems: string,
diff --git a/src/language/providers/attributeValueCompletion.ts b/src/language/providers/attributeValueCompletion.ts
index 35d902b..9ed3bfa 100644
--- a/src/language/providers/attributeValueCompletion.ts
+++ b/src/language/providers/attributeValueCompletion.ts
@@ -15,6 +15,29 @@
* limitations under the License.
*/
+/**
+ * Attribute Value Completion Provider for DFDL and TDML Documents
+ *
+ * This module provides intelligent completion suggestions for attribute values in DFDL schemas
+ * and TDML test files. It offers context-aware value suggestions based on:
+ * - The attribute name (e.g., different values for dfdl:representation, dfdl:length, etc.)
+ * - Valid enumerated values from the DFDL specification
+ * - Previously defined types (for type references)
+ * - Previously defined variables (for variable references)
+ * - Boolean values (true/false, yes/no) for boolean attributes
+ * - Standard values like encoding names, byte orders, etc.
+ *
+ * Features:
+ * - Enumerated value completion for DFDL properties with fixed value sets
+ * - Type name completion (references to xs:simpleType or xs:complexType definitions)
+ * - Variable name completion (references to dfdl:defineVariable declarations)
+ * - Custom completion items for attributes requiring user input
+ * - Filtering based on attribute context (element type, namespace, etc.)
+ * - Integration with DFDL and TDML specification data
+ *
+ * The provider is triggered when the user types opening quotes (\" or ') for an attribute value.
+ */
+
import * as vscode from 'vscode'
import {
@@ -28,6 +51,19 @@ import { getDefinedTypes } from './attributeCompletion'
import { attributeCompletion } from './intellisense/attributeItems'
import { noChoiceAttributes } from './intellisense/attributeValueItems'
+/**
+ * Registers the attribute value completion provider for DFDL documents.
+ * This provider suggests valid values for DFDL attributes based on the attribute name
+ * and context.
+ *
+ * The provider:
+ * 1. Identifies the attribute being edited
+ * 2. Looks up valid values for that attribute from the intellisense data
+ * 3. Includes user-defined types and variables as applicable
+ * 4. Provides completion items with appropriate snippets
+ *
+ * @returns A VS Code Disposable for the registered completion provider
+ */
export function getAttributeValueCompletionProvider() {
return vscode.languages.registerCompletionItemProvider(
'dfdl',
@@ -36,6 +72,9 @@ export function getAttributeValueCompletionProvider() {
document: vscode.TextDocument,
position: vscode.Position
) {
+ // Don't provide completion in these contexts:
+ // - Inside curly braces (DFDL expression language)
+ // - Outside of quoted strings (not in an attribute value)
if (
checkBraceOpen(document, position) ||
cursorWithinBraces(document, position) ||
@@ -76,6 +115,23 @@ export function getAttributeValueCompletionProvider() {
editBuilder.replace(range, replaceValue)
})
+ /**
+ * Generates appropriate completion snippets for attribute values based on the attribute name.
+ *
+ * This function is called by the completion provider when the cursor is positioned in an
+ * attribute value context. It uses a switch statement to map attribute names to their
+ * corresponding value snippets and inserts them at the specified position.
+ *
+ * @param attributeName - The name of the attribute being completed (without namespace prefix for most cases)
+ *
+ * Implementation Notes:
+ * ---------------------
+ * - Uses insertSnippet() utility to insert snippets at the cursor position
+ * - Snippet syntax: ${1|choice1,choice2|} for dropdowns, "$1" for free text
+ * - Expression attributes use "{$1}" to include required curly braces
+ * - Some attributes have default values (e.g., "0" for numeric properties)
+ * - Type attribute merges XSD primitive types with custom types from the schema
+ */
function getAttributeValues(attributeName: string) {
type AttributeItem = {
item: string
@@ -115,6 +171,16 @@ export function getAttributeValueCompletionProvider() {
)
}
+/**
+ * Registers the attribute value completion provider for TDML test documents.
+ * This provider suggests valid values for TDML-specific attributes such as:
+ * - Test types (parser, unparser, negative)
+ * - Validation modes (on, limited, off)
+ * - Encoding names (UTF-8, ASCII, ISO-8859-1, etc.)
+ * - Boolean values (true, false)
+ *
+ * @returns A VS Code Disposable for the registered completion provider
+ */
export function getTDMLAttributeValueCompletionProvider() {
return vscode.languages.registerCompletionItemProvider(
'dfdl',
@@ -123,6 +189,7 @@ export function getTDMLAttributeValueCompletionProvider() {
document: vscode.TextDocument,
position: vscode.Position
) {
+ // Don't provide completion inside curly braces (expressions)
if (
checkBraceOpen(document, position) ||
cursorWithinBraces(document, position)
@@ -200,6 +267,24 @@ export function getTDMLAttributeValueCompletionProvider() {
)
}
+/**
+ * Extracts details about the attribute being edited at the cursor position.
+ * Identifies the attribute name and the position range of its value (between quotes).
+ *
+ * The function:
+ * 1. Searches backwards to find the '=' sign and attribute name
+ * 2. Searches for the opening quote (' or ") after the '=' sign
+ * 3. Searches for the closing quote
+ * 4. Returns the attribute name and value range
+ *
+ * This information is used to provide context-appropriate attribute value completions
+ * and to replace the existing value when a completion is selected.
+ *
+ * @param document - The VS Code text document
+ * @param position - Current cursor position
+ * @returns Tuple of [attribute name, start position of value, end position of value]
+ * Returns ['none', 0, 0] if not in an attribute value context
+ */
function getAttributeDetails(
document: vscode.TextDocument,
position: vscode.Position
diff --git a/src/language/providers/intellisense/attributeItems.ts b/src/language/providers/intellisense/attributeItems.ts
index 64275fd..3985dcc 100644
--- a/src/language/providers/intellisense/attributeItems.ts
+++ b/src/language/providers/intellisense/attributeItems.ts
@@ -15,6 +15,65 @@
* limitations under the License.
*/
+/**
+ * Attribute Completion Items for DFDL/XSD Schema Intellisense
+ *
+ * This module provides static completion data for XML schema attributes used in DFDL (Data Format Description Language)
+ * and XSD (XML Schema Definition) documents. It is consumed by the completion provider to offer context-aware
+ * attribute suggestions as users type in DFDL schema files.
+ *
+ * Data Structure:
+ * ---------------
+ * The attributeCompletion function returns an object containing an array of completion items. Each item contains:
+ * - item: The attribute name to display in the completion list
+ * - snippetString: A VSCode snippet with placeholders ($1, $2, etc.) and default values
+ * - markdownString: Human-readable documentation shown in the completion tooltip
+ *
+ * Usage by Completion Provider:
+ * ------------------------------
+ * This data is used by src/language/providers/dfdl.ts to provide intelligent attribute completion when:
+ * - User types inside an XML element tag (e.g., <xs:element |)
+ * - User triggers completion manually with Ctrl+Space
+ * - Completion provider filters these items based on current context and element type
+ *
+ * Snippet Format:
+ * ---------------
+ * Snippets use VSCode snippet syntax:
+ * - $1, $2, etc.: Tab stop positions for user input
+ * - ${1|option1,option2|}: Choice placeholders with predefined options
+ * - $0: Final cursor position after all tab stops
+ * - spacingChar: Spacing before attribute (typically space)
+ * - afterChar: Character after attribute (typically space or >)
+ *
+ * DFDL Specification Reference:
+ * ------------------------------
+ * Attributes in this file are defined by:
+ * - DFDL v1.0 Specification: https://daffodil.apache.org/docs/dfdl/
+ * - XML Schema Part 1: Structures (for xs: attributes)
+ * - Attributes prefixed with dfdl: are DFDL-specific extensions to XSD
+ *
+ * Key Attribute Categories:
+ * -------------------------
+ * 1. XSD Core Attributes: name, ref, type, default, fixed, minOccurs, maxOccurs, nillable
+ * 2. Length Properties: dfdl:length, dfdl:lengthKind, dfdl:lengthUnits, dfdl:lengthPattern
+ * 3. Encoding Properties: dfdl:encoding, dfdl:encodingErrorPolicy, dfdl:utf16Width
+ * 4. Occurrence Properties: dfdl:occursCount, dfdl:occursCountKind, dfdl:occursStopValue
+ * 5. Byte/Bit Order: dfdl:byteOrder, dfdl:bitOrder
+ * 6. Text Representation: dfdl:textNumberPattern, dfdl:textStringJustification, dfdl:textPadKind
+ * 7. Binary Representation: dfdl:binaryNumberRep, dfdl:binaryFloatRep, dfdl:binaryBooleanTrueRep
+ * 8. Separators/Delimiters: dfdl:separator, dfdl:terminator, dfdl:initiator
+ * 9. Calendar/Date: dfdl:calendarPattern, dfdl:calendarTimeZone, dfdl:calendarPatternKind
+ * 10. Escape Schemes: dfdl:escapeSchemeRef, dfdl:escapeCharacter, dfdl:escapeBlockStart
+ * 11. Assertions: testKind, test, testPattern, message, failureType
+ * 12. Schema Organization: schemaLocation, namespace
+ *
+ * @param additionalItems - Additional completion items to merge with the standard set
+ * @param nsPrefix - Namespace prefix for schema elements (typically "xs:" or "xsd:")
+ * @param dfdlPrefix - DFDL namespace prefix (typically "dfdl:")
+ * @param spacingChar - Character to insert before attribute (typically " ")
+ * @param afterChar - Character to insert after attribute value (typically " " or ">")
+ * @returns Object containing array of completion items with snippets and documentation
+ */
// prettier-ignore
export const attributeCompletion = (
additionalItems,
@@ -24,7 +83,11 @@ export const attributeCompletion = (
afterChar: string
) => {
return {
+ // Array of completion item objects, each representing a DFDL/XSD attribute with its snippet and documentation
items: [
+ // === XSD Core Attributes ===
+ // These are fundamental XML Schema attributes used for element definition and reference
+
{
item: 'name',
snippetString: spacingChar + 'name="$1"$0' + afterChar,
@@ -60,6 +123,9 @@ export const attributeCompletion = (
snippetString: spacingChar + 'nillable="${true|false|}"$0' + afterChar,
markdownString: 'Allows for the concept of an element having no value',
},
+ // === DFDL Occurrence Control Properties ===
+ // These properties control how many times an element occurs in the data stream
+
{
item: 'type',
snippetString: spacingChar + 'type="${1|xs:string,xs:decimal,xs:float,xs:double,xs:integer,xs:nonNegativeInteger,xs:int,xs:unsignedInt,xs:short,xs:unsignedShort,xs:long,xs:unsignedLong,xs:byte,xs:unsignedByte,xs:hexBinary,xs:boolean' +
@@ -79,16 +145,6 @@ export const attributeCompletion = (
snippetString: spacingChar + dfdlPrefix + 'occursCount="$1"$0' + afterChar,
markdownString: 'dfdl:occursCount property takes an expression which commonly looks in the Infoset via an expression, to obtain the count from another element.',
},
- {
- item: 'dfdl:byteOrder',
- snippetString: spacingChar + dfdlPrefix + 'byteOrder="${1|bigEndian,littleEndian|}"$0' + afterChar,
- markdownString: 'This property applies to all Number, Calendar (date and time), and Boolean types with representation binary',
- },
- {
- item: 'dfdl:bitOrder',
- snippetString: spacingChar + dfdlPrefix + 'bitOrder="${1|mostSignificantBitFirst,leastSignificantBitFirst|}"$0' + afterChar,
- markdownString: 'Determines the specific bits of any grammar region',
- },
{
item: 'dfdl:occursCountKind',
snippetString: spacingChar + dfdlPrefix + 'occursCountKind="${1|expression,fixed,implicit,parsed,stopValue|}"$0' + afterChar,
@@ -99,6 +155,24 @@ export const attributeCompletion = (
snippetString: spacingChar + dfdlPrefix + 'occursStopValue="$1"$0' + afterChar,
markdownString: 'A whitespace separated list of logical values that specify the alternative logical stop values for the element',
},
+
+ // === DFDL Byte and Bit Order Properties ===
+ // Control the ordering of bytes and bits in binary data
+
+ {
+ item: 'dfdl:byteOrder',
+ snippetString: spacingChar + dfdlPrefix + 'byteOrder="${1|bigEndian,littleEndian|}"$0' + afterChar,
+ markdownString: 'This property applies to all Number, Calendar (date and time), and Boolean types with representation binary',
+ },
+ {
+ item: 'dfdl:bitOrder',
+ snippetString: spacingChar + dfdlPrefix + 'bitOrder="${1|mostSignificantBitFirst,leastSignificantBitFirst|}"$0' + afterChar,
+ markdownString: 'Determines the specific bits of any grammar region',
+ },
+
+ // === DFDL Length Properties ===
+ // Define how the length of an element is determined and represented
+
{
item: 'dfdl:length',
snippetString: spacingChar + dfdlPrefix + 'length="$1"$0',
@@ -119,6 +193,10 @@ export const attributeCompletion = (
snippetString: spacingChar + dfdlPrefix + 'prefixLengthType="$1"$0' + afterChar,
markdownString: 'Name of a simple type derived from xs:integer or any subtype of it.',
},
+
+ // === DFDL Encoding Properties ===
+ // Control character encoding and text handling
+
{
item: 'dfdl:utf16Width',
snippetString: spacingChar + dfdlPrefix + 'utf16Width="${1|fixed,variable|}"$0' + afterChar,
@@ -134,6 +212,10 @@ export const attributeCompletion = (
snippetString: spacingChar + dfdlPrefix + 'encodingErrorPolicy="${1|error,replace|}"$0' + afterChar,
markdownString: 'This property provides control of how decoding and encoding errors are handled when converting the data to text, or text to data',
},
+
+ // === DFDL Nil/Null Value Properties ===
+ // Handle nil (null) values in data streams
+
{
item: 'dfdl:nilKind',
snippetString: spacingChar + dfdlPrefix + 'nilKind="${1|literalCharacter,literalValue,logicalValue|}"$0' + afterChar,
@@ -154,6 +236,10 @@ export const attributeCompletion = (
snippetString: spacingChar + dfdlPrefix + 'useNilForDefault="${1|yes,no|}"$0' + afterChar,
markdownString: 'Controls whether to set the Infoset item [nilled] boolean member, or to use the XSD default or fixed properties to obtain a data value'
},
+
+ // === DFDL Alignment and Positioning Properties ===
+ // Control byte/bit alignment and skip regions
+
{
item: 'dfdl:alignment',
snippetString: spacingChar + dfdlPrefix + 'alignment="${1|1,2,implicit|}"$0' + afterChar,
@@ -184,21 +270,62 @@ export const attributeCompletion = (
snippetString: spacingChar + dfdlPrefix + 'alignmentUnits="${1|bits,bytes|}"$0' + afterChar,
markdownString: "Scales the alignment.\nCan only be used when alignment is bits or bytes.\nValid values are 'bits or 'bytes'.",
},
+ {
+ item: 'dfdl:leadingSkip',
+ snippetString: spacingChar + dfdlPrefix + 'leadingSkip="0$1"$0' + afterChar,
+ markdownString: 'A non-negative number of bytes or bits to skip before alignment is applied',
+ },
+ {
+ item: 'dfdl:trailingSkip',
+ snippetString: spacingChar + dfdlPrefix + 'trailingSkip="0$1"$0' + afterChar,
+ markdownString: 'A non-negative number of bytes or bits to skip after the element,',
+ },
+
+ // === DFDL Output Control Properties ===
+ // Control unparsing behavior and output formatting
+
{
item: 'dfdl:outputNewLine',
snippetString: spacingChar + dfdlPrefix + 'outputNewLine="${1|%CR;,%LF;,%CR;%LF;,%NEL;,%LS;|}"$0' + afterChar,
markdownString: 'Specifies the character or characters that are used to replace the %NL; character class entity during unparse',
},
+
+ // === DFDL Choice and Branching Properties ===
+ // Control xs:choice element behavior and direct/dispatch choices
+
{
item: 'dfdl:choiceBranchKey',
snippetString: spacingChar + dfdlPrefix + 'choiceBranchKey="$1"$0' + afterChar,
markdownString: 'List of DFDL String Literals',
},
+ {
+ item: 'dfdl:choiceDispatchKey',
+ snippetString: spacingChar + dfdlPrefix + 'choiceDispatchKey="$1"$0' + afterChar,
+ markdownString: 'The expression must evaluate to a string, the string must match one of the dfdl:choiceBranchKey property values of one of the branches of the choice',
+ },
+ {
+ item: 'dfdl:choiceLengthKind',
+ snippetString: spacingChar + dfdlPrefix + 'choiceLengthKind="${1|explicit,implicit|}"$0' + afterChar,
+ markdownString: 'Determines whether the branches of the choice are always filled (explicit) to the fixed-length specified by dfdl:choiceLength or not filled (implicit)',
+ },
+ {
+ item: 'dfdl:choiceLength',
+ snippetString: spacingChar + dfdlPrefix + 'choiceLength="$1"$0' + afterChar,
+ markdownString: 'Specifies the length of the choice in bytes, only used when dfdl:choiceLengthKind is explicit',
+ },
+
+ // === DFDL Representation Properties ===
+ // Control whether data is represented as text or binary
+
{
item: 'dfdl:representation',
snippetString: spacingChar + dfdlPrefix + 'representation="${1|binary,text|}"$0' + afterChar,
markdownString: 'Identifies the physical representation of the element as text or binary',
},
+
+ // === DFDL Text String Properties ===
+ // Properties specific to text representation of string data
+
{
item: 'dfdl:textStringJustification',
snippetString: spacingChar + dfdlPrefix + 'textStringJustification="${1|left,right,center|}"$0' + afterChar,
@@ -209,6 +336,15 @@ export const attributeCompletion = (
snippetString: spacingChar + dfdlPrefix + 'textStringPadCharacter="$1"$0' + afterChar,
markdownString: 'Specifies the string justification',
},
+ {
+ item: 'dfdl:truncateSpecifiedLengthString',
+ snippetString: spacingChar + dfdlPrefix + 'truncateSpecifiedLengthString="${1|no,yes|}"$0' + afterChar,
+ markdownString: 'This property provides the means to express an error, or the strings can be truncated to fit when the strings in an Infoset being unparsed do not fit within those specified lengths',
+ },
+
+ // === DFDL Text Number Properties ===
+ // Properties for parsing and unparsing numeric data in text representation
+
{
item: 'dfdl:textStandardZeroRep',
snippetString: spacingChar + dfdlPrefix + 'textStandardZeroRep="0"$0' + afterChar,
@@ -309,6 +445,10 @@ export const attributeCompletion = (
snippetString: spacingChar + dfdlPrefix + 'textTrimKind="${1|none,padChar|}"$0' + afterChar,
markdownString: 'Indicates whether to trim data on parsing',
},
+
+ // === DFDL Text Boolean Properties ===
+ // Properties for text representation of boolean values
+
{
item: 'dfdl:textBooleanTrueRep',
snippetString: spacingChar + dfdlPrefix + 'textBooleanTrueRep="$1"$0' + afterChar,
@@ -329,21 +469,10 @@ export const attributeCompletion = (
snippetString: spacingChar + dfdlPrefix + 'textBooleanPadCharacter="$1"$0' + afterChar,
markdownString: 'The value that is used when padding or trimming boolean elements',
},
- {
- item: 'dfdl:leadingSkip',
- snippetString: spacingChar + dfdlPrefix + 'leadingSkip="0$1"$0' + afterChar,
- markdownString: 'A non-negative number of bytes or bits to skip before alignment is applied',
- },
- {
- item: 'dfdl:trailingSkip',
- snippetString: spacingChar + dfdlPrefix + 'trailingSkip="0$1"$0' + afterChar,
- markdownString: 'A non-negative number of bytes or bits to skip after the element,',
- },
- {
- item: 'dfdl:truncateSpecifiedLengthString',
- snippetString: spacingChar + dfdlPrefix + 'truncateSpecifiedLengthString="${1|no,yes|}"$0' + afterChar,
- markdownString: 'This property provides the means to express an error, or the strings can be truncated to fit when the strings in an Infoset being unparsed do not fit within those specified lengths',
- },
+
+ // === DFDL Sequence Properties ===
+ // Properties for xs:sequence groups controlling ordering and separators
+
{
item: 'dfdl:sequenceKind',
snippetString: spacingChar + dfdlPrefix + 'SequenceKind ="${1|ordered,unordered|}"$0' + afterChar,
@@ -364,11 +493,48 @@ export const attributeCompletion = (
snippetString: spacingChar + dfdlPrefix + 'separatorSuppressionPolicy="${1|anyEmpty,never,trailingEmpty,trailingEmptyStrict|}"$0' + afterChar,
markdownString: 'Controls the circumstances when separators are expected in the data when parsing, or generated when unparsing',
},
+
+ // === DFDL Delimiter Properties ===
+ // Properties for initiators and terminators marking element boundaries
+
{
item: 'dfdl:terminator',
snippetString: spacingChar + dfdlPrefix + 'terminator="$1"$0' + afterChar,
markdownString: 'charater or bytes found in the input stream that designate termination of an element',
},
+ {
+ item: 'dfdl:initiator',
+ snippetString: spacingChar + dfdlPrefix + 'initiator="$1"$0' + afterChar,
+ markdownString: 'Specifies an ordered whitespace separated list of alternative DFDL String Literals one of which marks the beginning of the element or group of elements ',
+ },
+ {
+ item: 'dfdl:initiatedContent',
+ snippetString: spacingChar + dfdlPrefix + 'initiatedContent="${1|yes,no|}"$0' + afterChar,
+ markdownString: 'yes indicates all branches of a choice are initiated\nno indicates the branch dfdl:initator property may be ste to empty string',
+ },
+ {
+ item: "dfdl:documentFinalTerminatorCanBeMissing" + afterChar,
+ snippetString: spacingChar + dfdlPrefix + 'documentFinalTerminatorCanBeMissing="${1|yes,no|}"$0',
+ markdownString: 'Specifies whether the final line can be missing',
+ },
+
+ // === DFDL Empty Element Properties ===
+ // Control behavior when elements have no content
+
+ {
+ item:'dfdl:emptyValueDelimiterPolicy',
+ snippetString: spacingChar + dfdlPrefix + 'emptyValueDelimiterPolicy="${1|initiator,terminator,both,none|}"$0' + afterChar,
+ markdownString: 'Indicates which of initiator, terminator, both, or neither must be present when an element in the data stream is empty.',
+ },
+ {
+ item:'dfdl:emptyElementParsePolicy',
+ snippetString: spacingChar + dfdlPrefix + 'emptyElementParsePolicy="${1|treatAsAbsent,treatAsEmpty|}"$0' + afterChar,
+ markdownString: 'Indicates which of initiator, terminator, both, or neither must be present when an element in the data stream is empty.',
+ },
+
+ // === DFDL Miscellaneous Properties ===
+ // Additional properties for special features
+
{
item: 'dfdl:textBidi',
snippetString: spacingChar + dfdlPrefix + 'textBidi="${1|no,yes|}"$0' + afterChar,
@@ -379,16 +545,6 @@ export const attributeCompletion = (
snippetString: spacingChar + 'dfdl:hiddenGroupRef="$1"$0' + afterChar,
markdownString: 'Reference to a global model group definition',
},
- {
- item: 'dfdl:choiceLengthKind',
- snippetString: spacingChar + dfdlPrefix + 'choiceLengthKind="${1|explicit,implicit|}"$0' + afterChar,
- markdownString: 'Determines whether the branches of the choice are always filled (explicit) to the fixed-length specified by dfdl:choiceLength or not filled (implicit)',
- },
- {
- item: 'dfdl:choiceLength',
- snippetString: spacingChar + dfdlPrefix + 'choiceLength="$1"$0' + afterChar,
- markdownString: 'Specifies the length of the choice in bytes, only used when dfdl:choiceLengthKind is explicit',
- },
{
item: 'dfdl:fillByte',
snippetString: spacingChar + dfdlPrefix + 'fillByte="$1"$0' + afterChar,
@@ -399,21 +555,10 @@ export const attributeCompletion = (
snippetString: spacingChar + dfdlPrefix + 'ignoreCase="${1|no,yes|}"$0' + afterChar,
markdownString: 'Whether mixed case data is accepted when matching delimiters and data values on input',
},
- {
- item: 'dfdl:initiatedContent',
- snippetString: spacingChar + dfdlPrefix + 'initiatedContent="${1|yes,no|}"$0' + afterChar,
- markdownString: 'yes indicates all branches of a choice are initiated\nno indicates the branch dfdl:initator property may be ste to empty string',
- },
- {
- item: 'dfdl:initiator',
- snippetString: spacingChar + dfdlPrefix + 'initiator="$1"$0' + afterChar,
- markdownString: 'Specifies an ordered whitespace separated list of alternative DFDL String Literals one of which marks the beginning of the element or group of elements ',
- },
- {
- item: 'dfdl:choiceDispatchKey',
- snippetString: spacingChar + dfdlPrefix + 'choiceDispatchKey="$1"$0' + afterChar,
- markdownString: 'The expression must evaluate to a string, the string must match one of the dfdl:choiceBranchKey property values of one of the branches of the choice',
- },
+
+ // === DFDL Binary Number Properties ===
+ // Properties for binary representation of numeric values
+
{
item: 'dfdl:binaryNumberRep',
snippetString: spacingChar + dfdlPrefix + 'binaryNumberRep="${1|binary,packed,bcd,ibm4690Packed|}"$0' + afterChar,
@@ -444,6 +589,10 @@ export const attributeCompletion = (
snippetString: spacingChar + dfdlPrefix + 'binaryNumberCheckPolicy="${1|strict,lax|}"$0' + afterChar,
markdownString: 'Indicates how lenient to be when parsing binary numbers',
},
+
+ // === DFDL Binary Boolean Properties ===
+ // Properties for binary representation of boolean values
+
{
item: 'dfdl:binaryBooleanTrueRep',
snippetString: spacingChar + dfdlPrefix + 'binaryBooleanTrueRep="$1"$0' + afterChar,
@@ -454,6 +603,10 @@ export const attributeCompletion = (
snippetString: spacingChar + dfdlPrefix + 'binaryBooleanFalseRep="$1"$0' + afterChar,
markdownString: 'A binary xs:unsignedInt gives the representation for false',
},
+
+ // === DFDL Calendar/Date-Time Properties ===
+ // Properties for parsing and unparsing date/time data
+
{
item: 'dfdl:calendarPattern',
snippetString: spacingChar + dfdlPrefix + 'calendarPattern="$1"$0' + afterChar,
@@ -519,21 +672,10 @@ export const attributeCompletion = (
snippetString: spacingChar + dfdlPrefix + 'binaryCalendarEpoch="$1"$0' + afterChar,
markdownString: 'The epoch from which to calculate dates and times. Used when dfdl:binaryCalendarRep is binarySeconds or binaryMilliseconds',
},
- {
- item: "dfdl:documentFinalTerminatorCanBeMissing" + afterChar,
- snippetString: spacingChar + dfdlPrefix + 'documentFinalTerminatorCanBeMissing="${1|yes,no|}"$0',
- markdownString: 'Specifies whether the final line can be missing',
- },
- {
- item:'dfdl:emptyValueDelimiterPolicy',
- snippetString: spacingChar + dfdlPrefix + 'emptyValueDelimiterPolicy="${1|initiator,terminator,both,none|}"$0' + afterChar,
- markdownString: 'Indicates which of initiator, terminator, both, or neither must be present when an element in the data stream is empty.',
- },
- {
- item:'dfdl:emptyElementParsePolicy',
- snippetString: spacingChar + dfdlPrefix + 'emptyElementParsePolicy="${1|treatAsAbsent,treatAsEmpty|}"$0' + afterChar,
- markdownString: 'Indicates which of initiator, terminator, both, or neither must be present when an element in the data stream is empty.',
- },
+
+ // === DFDL Escape Scheme Properties ===
+ // Properties for defining and using escape mechanisms
+
{
item: 'dfdl:escapeSchemeRef',
snippetString: spacingChar + dfdlPrefix + 'escapeSchemeRef="$1"$0' + afterChar,
@@ -579,6 +721,10 @@ export const attributeCompletion = (
snippetString: spacingChar + dfdlPrefix + 'escapeCharacterPolicy="${1|all,delimiters|}"$0' + afterChar,
markdownString: "The type of escape mechanism defined in the escape scheme",
},
+
+ // === DFDL Assert and Discriminator Properties ===
+ // Properties for assertions and discriminators used in validation and disambiguation
+
{
item: 'testKind',
snippetString: spacingChar + 'testKind="${1|expression,pattern|}"$0' + afterChar,
@@ -604,6 +750,10 @@ export const attributeCompletion = (
snippetString: spacingChar + 'failureType="${1|processingError,recoverableError|}"$0' + afterChar,
markdownString: 'Specifies the type of failure that occurs when the dfdl:assert is unsuccessful',
},
+
+ // === XSD Schema Organization Attributes ===
+ // Attributes for schema imports and includes
+
{
item: 'schemaLocation',
snippetString: spacingChar + 'schemaLocation="$1"$0' + afterChar,
diff --git a/src/language/providers/intellisense/attributeValueItems.ts b/src/language/providers/intellisense/attributeValueItems.ts
index b96cb75..93c3eff 100644
--- a/src/language/providers/intellisense/attributeValueItems.ts
+++ b/src/language/providers/intellisense/attributeValueItems.ts
@@ -15,6 +15,17 @@
* limitations under the License.
*/
+/**
+ * List of attribute names that should NOT show completion choices.
+ * These are typically free-form text attributes where showing predefined
+ * options would not be helpful, such as:
+ * - Names and references (name, ref, namespace)
+ * - Expressions and patterns (inputValueCalc, outputValueCalc, test, testPattern)
+ * - Numeric values (length, occursCount, textOutputMinLength)
+ * - Custom strings (separator, terminator, initiator, nilValue)
+ * - Type names (prefixLengthType)
+ * - Escape characters and patterns
+ */
export const noChoiceAttributes = [
'name',
'ref',