@ktjs/ts-plugin 0.1.5 → 0.1.7

package/README.md

@@ -8,10 +8,11 @@ TypeScript language service plugin for KT.js `k-for` scope variables in TSX.
 - Suppresses TS2304 (`Cannot find name ...`) for aliases declared by `k-for`.
 - Infers alias types from iterable/indexed sources (for example `k-for="item in users"` makes `item` resolve to `users[number]`).
 - Provides hover type info and member completions for inferred aliases.
+- Supports hover type info inside `k-for` expression strings (`item in users`) for alias/source identifiers.
+- Adds `k-for` inline semantic highlighting in string expressions (for example alias/keyword/source in `k-for="item in list"`).
 - Supports Vue-like syntax:
   - `k-for="item in list"`
   - `k-for="(item, i) in list"`
-  - `k-for="(value, key, i) in mapLike"`
 
 ## Install
 

package/dist/index.js

@@ -4,6 +4,8 @@ const completion_1 = require("./completion");
 const constants_1 = require("./constants");
 const config_1 = require("./config");
 const identifiers_1 = require("./identifiers");
+const kfor_highlighting_1 = require("./kfor-highlighting");
+const quickinfo_1 = require("./quickinfo");
 const scope_analysis_1 = require("./scope-analysis");
 const type_resolution_1 = require("./type-resolution");
 function init(modules) {
@@ -38,6 +40,28 @@ function init(modules) {
                 return !(0, scope_analysis_1.isSuppressed)(diagnostic.start, name, analysis.scopes);
             });
         };
+        proxy.getEncodedSemanticClassifications = (fileName, span, format) => {
+            const classifications = languageService.getEncodedSemanticClassifications(fileName, span, format);
+            if (!(0, config_1.isJsxLikeFile)(fileName)) {
+                return classifications;
+            }
+            const sourceFile = languageService.getProgram()?.getSourceFile(fileName);
+            if (!sourceFile) {
+                return classifications;
+            }
+            return (0, kfor_highlighting_1.addKForSemanticClassifications)(classifications, sourceFile, span, format, ts, config);
+        };
+        proxy.getEncodedSyntacticClassifications = (fileName, span) => {
+            const classifications = languageService.getEncodedSyntacticClassifications(fileName, span);
+            if (!(0, config_1.isJsxLikeFile)(fileName)) {
+                return classifications;
+            }
+            const sourceFile = languageService.getProgram()?.getSourceFile(fileName);
+            if (!sourceFile) {
+                return classifications;
+            }
+            return (0, kfor_highlighting_1.addKForSyntacticClassifications)(classifications, sourceFile, span, ts, config);
+        };
         proxy.getQuickInfoAtPosition = (fileName, position) => {
             const quickInfo = languageService.getQuickInfoAtPosition(fileName, position);
             if (!(0, config_1.isJsxLikeFile)(fileName)) {
@@ -47,25 +71,8 @@ function init(modules) {
             if (!analysis) {
                 return quickInfo;
             }
-            const identifier = (0, ast_1.findIdentifierAtPosition)(analysis.sourceFile, position, ts);
-            if (!identifier) {
-                return quickInfo;
-            }
-            const bindings = (0, scope_analysis_1.collectBindingsAtPosition)(position, analysis.scopes);
-            const binding = bindings.get(identifier.text);
-            if (!binding) {
-                return quickInfo;
-            }
-            const typeText = (0, type_resolution_1.formatTypeList)(binding.types, analysis.checker, identifier, ts);
-            return {
-                kind: ts.ScriptElementKind.localVariableElement,
-                kindModifiers: '',
-                textSpan: {
-                    start: identifier.getStart(analysis.sourceFile),
-                    length: identifier.getWidth(analysis.sourceFile),
-                },
-                displayParts: [{ text: `(k-for) ${binding.name}: ${typeText}`, kind: 'text' }],
-            };
+            const pluginQuickInfo = (0, quickinfo_1.getKForQuickInfoAtPosition)(analysis, position, ts, config);
+            return pluginQuickInfo || quickInfo;
         };
         proxy.getCompletionsAtPosition = (fileName, position, options, formattingSettings) => {
             const completions = languageService.getCompletionsAtPosition(fileName, position, options, formattingSettings);

package/dist/kfor-highlighting.d.ts

@@ -0,0 +1,4 @@
+import type tsModule from 'typescript/lib/tsserverlibrary';
+import type { ResolvedConfig } from './types';
+export declare function addKForSemanticClassifications(base: tsModule.Classifications, sourceFile: tsModule.SourceFile, span: tsModule.TextSpan, format: tsModule.SemanticClassificationFormat | undefined, ts: typeof tsModule, config: ResolvedConfig): tsModule.Classifications;
+export declare function addKForSyntacticClassifications(base: tsModule.Classifications, sourceFile: tsModule.SourceFile, span: tsModule.TextSpan, ts: typeof tsModule, config: ResolvedConfig): tsModule.Classifications;

package/dist/kfor-highlighting.js

@@ -0,0 +1,407 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addKForSemanticClassifications = addKForSemanticClassifications;
+exports.addKForSyntacticClassifications = addKForSyntacticClassifications;
+const jsx_attributes_1 = require("./jsx-attributes");
+const kfor_parser_1 = require("./kfor-parser");
+const identifiers_1 = require("./identifiers");
+const TOKEN_TYPE_VARIABLE = 7;
+const TOKEN_TYPE_TYPE = 5;
+const TOKEN_MODIFIER_READONLY = 1 << 3;
+const TOKEN_MODIFIER_LOCAL = 1 << 5;
+const TOKEN_ENCODING_TYPE_OFFSET = 8;
+const IDENTIFIER_PATTERN = /[A-Za-z_$][A-Za-z0-9_$]*/g;
+const KEYWORD_DELIMITER_PATTERN = /\s+(in|of)\s+/;
+function addKForSemanticClassifications(base, sourceFile, span, format, ts, config) {
+    const tokens = collectHighlightTokens(sourceFile, ts, config, span);
+    if (tokens.length === 0) {
+        return base;
+    }
+    const semanticSpans = buildSemanticSpans(tokens, format, ts);
+    if (semanticSpans.length === 0) {
+        return base;
+    }
+    return mergeClassifications(base, semanticSpans, false);
+}
+function addKForSyntacticClassifications(base, sourceFile, span, ts, config) {
+    const tokens = collectHighlightTokens(sourceFile, ts, config, span);
+    if (tokens.length === 0) {
+        return base;
+    }
+    const keywordSpans = buildSyntacticKeywordSpans(tokens, ts);
+    if (keywordSpans.length === 0) {
+        return base;
+    }
+    return mergeClassifications(base, keywordSpans, true);
+}
+function collectHighlightTokens(sourceFile, ts, config, span) {
+    const tokens = [];
+    const spanStart = span.start;
+    const spanEnd = span.start + span.length;
+    const visit = (node) => {
+        let opening;
+        if (ts.isJsxElement(node)) {
+            opening = node.openingElement;
+        }
+        else if (ts.isJsxSelfClosingElement(node)) {
+            opening = node;
+        }
+        if (opening) {
+            const attr = (0, jsx_attributes_1.getJsxAttribute)(opening, config.forAttr, ts);
+            if (attr) {
+                const parsed = parseKForAttributeTokens(attr, sourceFile, ts, config.allowOfKeyword);
+                for (let i = 0; i < parsed.length; i++) {
+                    const token = parsed[i];
+                    const tokenStart = token.start;
+                    const tokenEnd = token.start + token.length;
+                    if (tokenEnd <= spanStart || tokenStart >= spanEnd) {
+                        continue;
+                    }
+                    const clippedStart = Math.max(tokenStart, spanStart);
+                    const clippedEnd = Math.min(tokenEnd, spanEnd);
+                    if (clippedEnd > clippedStart) {
+                        tokens.push({
+                            start: clippedStart,
+                            length: clippedEnd - clippedStart,
+                            kind: token.kind,
+                        });
+                    }
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return uniqueTokens(tokens);
+}
+function parseKForAttributeTokens(attr, sourceFile, ts, allowOfKeyword) {
+    const content = getAttributeRawContent(attr, sourceFile, ts);
+    if (!content) {
+        return [];
+    }
+    const raw = content.text;
+    const rawOffset = content.start;
+    const value = raw.trim();
+    if (!value) {
+        return [];
+    }
+    const parsed = (0, kfor_parser_1.parseKForExpression)(value, allowOfKeyword);
+    if (!parsed) {
+        return [];
+    }
+    const trimStart = raw.length - raw.trimStart().length;
+    const delimiterMatch = KEYWORD_DELIMITER_PATTERN.exec(value);
+    if (!delimiterMatch) {
+        return [];
+    }
+    const keyword = delimiterMatch[1];
+    const keywordOffsetInDelimiter = delimiterMatch[0].indexOf(keyword);
+    const leftSegment = value.slice(0, delimiterMatch.index);
+    const rightSegment = value.slice(delimiterMatch.index + delimiterMatch[0].length);
+    const leftLeading = leftSegment.length - leftSegment.trimStart().length;
+    const leftTrimmed = leftSegment.trim();
+    let aliasText = leftTrimmed;
+    let aliasTextStartInRaw = trimStart + leftLeading;
+    if (leftTrimmed.startsWith('(') && leftTrimmed.endsWith(')')) {
+        aliasText = leftTrimmed.slice(1, -1);
+        aliasTextStartInRaw += 1;
+    }
+    const rightLeading = rightSegment.length - rightSegment.trimStart().length;
+    const sourceText = rightSegment.trim();
+    const sourceTextStartInRaw = trimStart + delimiterMatch.index + delimiterMatch[0].length + rightLeading;
+    const keywordStartInRaw = trimStart + delimiterMatch.index + keywordOffsetInDelimiter;
+    const tokens = [];
+    const aliasTokens = collectAliasTokens(aliasText, aliasTextStartInRaw, parsed.aliases);
+    for (let i = 0; i < aliasTokens.length; i++) {
+        tokens.push({
+            start: rawOffset + aliasTokens[i].start,
+            length: aliasTokens[i].length,
+            kind: 'alias',
+        });
+    }
+    tokens.push({
+        start: rawOffset + keywordStartInRaw,
+        length: keyword.length,
+        kind: 'keyword',
+    });
+    const sourceTokens = collectSourceTokens(sourceText, sourceTextStartInRaw, ts);
+    for (let i = 0; i < sourceTokens.length; i++) {
+        tokens.push({
+            start: rawOffset + sourceTokens[i].start,
+            length: sourceTokens[i].length,
+            kind: 'source',
+        });
+    }
+    return tokens;
+}
+function collectAliasTokens(aliasText, baseStart, aliases) {
+    const result = [];
+    const allowed = new Set(aliases);
+    let match;
+    IDENTIFIER_PATTERN.lastIndex = 0;
+    while ((match = IDENTIFIER_PATTERN.exec(aliasText))) {
+        const name = match[0];
+        if (!allowed.has(name) || !(0, identifiers_1.isValidIdentifier)(name)) {
+            continue;
+        }
+        result.push({
+            start: baseStart + match.index,
+            length: name.length,
+            kind: 'alias',
+        });
+    }
+    return result;
+}
+function collectSourceTokens(sourceText, baseStart, ts) {
+    const tokens = collectSourceTokensWithAst(sourceText, baseStart, ts);
+    if (tokens.length > 0) {
+        return tokens;
+    }
+    const fallback = [];
+    let match;
+    IDENTIFIER_PATTERN.lastIndex = 0;
+    while ((match = IDENTIFIER_PATTERN.exec(sourceText))) {
+        const name = match[0];
+        if (!(0, identifiers_1.isValidIdentifier)(name)) {
+            continue;
+        }
+        fallback.push({
+            start: baseStart + match.index,
+            length: name.length,
+            kind: 'source',
+        });
+    }
+    return fallback;
+}
+function collectSourceTokensWithAst(sourceText, baseStart, ts) {
+    const snippet = `(${sourceText});`;
+    const tempSourceFile = ts.createSourceFile('__k_for_highlight.ts', snippet, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    if (tempSourceFile.statements.length === 0) {
+        return [];
+    }
+    const statement = tempSourceFile.statements[0];
+    if (!ts.isExpressionStatement(statement)) {
+        return [];
+    }
+    const result = [];
+    const visit = (node) => {
+        if (ts.isIdentifier(node) && (0, identifiers_1.isValidIdentifier)(node.text)) {
+            const start = node.getStart(tempSourceFile) - 1;
+            const end = start + node.getWidth(tempSourceFile);
+            if (start >= 0 && end <= sourceText.length) {
+                result.push({
+                    start: baseStart + start,
+                    length: end - start,
+                    kind: 'source',
+                });
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(statement.expression);
+    return result;
+}
+function getAttributeRawContent(attr, sourceFile, ts) {
+    const initializer = attr.initializer;
+    if (!initializer) {
+        return undefined;
+    }
+    if (ts.isStringLiteral(initializer)) {
+        const quotedText = initializer.getText(sourceFile);
+        if (quotedText.length < 2) {
+            return undefined;
+        }
+        return {
+            start: initializer.getStart(sourceFile) + 1,
+            text: quotedText.slice(1, -1),
+        };
+    }
+    const expression = (0, jsx_attributes_1.getAttributeExpression)(attr, ts);
+    if (!expression || !ts.isStringLiteralLike(expression)) {
+        return undefined;
+    }
+    const quotedText = expression.getText(sourceFile);
+    if (quotedText.length < 2) {
+        return undefined;
+    }
+    return {
+        start: expression.getStart(sourceFile) + 1,
+        text: quotedText.slice(1, -1),
+    };
+}
+function buildSemanticSpans(tokens, format, ts) {
+    const spans = [];
+    if (format === ts.SemanticClassificationFormat.TwentyTwenty) {
+        for (let i = 0; i < tokens.length; i++) {
+            const token = tokens[i];
+            spans.push({
+                start: token.start,
+                length: token.length,
+                classification: token.kind === 'alias'
+                    ? encodeSemantic2020(TOKEN_TYPE_VARIABLE, TOKEN_MODIFIER_READONLY | TOKEN_MODIFIER_LOCAL)
+                    : token.kind === 'keyword'
+                        ? encodeSemantic2020(TOKEN_TYPE_TYPE, 0)
+                        : encodeSemantic2020(TOKEN_TYPE_VARIABLE, 0),
+            });
+        }
+        return spans;
+    }
+    for (let i = 0; i < tokens.length; i++) {
+        const token = tokens[i];
+        spans.push({
+            start: token.start,
+            length: token.length,
+            classification: token.kind === 'keyword' ? ts.ClassificationType.keyword : ts.ClassificationType.identifier,
+        });
+    }
+    return spans;
+}
+function buildSyntacticKeywordSpans(tokens, ts) {
+    const spans = [];
+    for (let i = 0; i < tokens.length; i++) {
+        const token = tokens[i];
+        if (token.kind !== 'keyword') {
+            continue;
+        }
+        spans.push({
+            start: token.start,
+            length: token.length,
+            classification: ts.ClassificationType.keyword,
+        });
+    }
+    return spans;
+}
+function encodeSemantic2020(typeIndex, modifiers) {
+    return ((typeIndex + 1) << TOKEN_ENCODING_TYPE_OFFSET) + modifiers;
+}
+function mergeClassifications(base, overlays, replaceOverlaps) {
+    if (overlays.length === 0) {
+        return base;
+    }
+    const baseSpans = decodeSpans(base.spans);
+    const extraSpans = normalizeSpans(overlays);
+    if (extraSpans.length === 0) {
+        return base;
+    }
+    const merged = replaceOverlaps
+        ? [...removeOverlayOverlaps(baseSpans, extraSpans), ...extraSpans]
+        : [...baseSpans, ...extraSpans];
+    const normalized = normalizeSpans(merged);
+    return {
+        spans: encodeSpans(normalized),
+        endOfLineState: base.endOfLineState,
+    };
+}
+function removeOverlayOverlaps(baseSpans, overlays) {
+    const result = [];
+    for (let i = 0; i < baseSpans.length; i++) {
+        let segments = [baseSpans[i]];
+        for (let j = 0; j < overlays.length; j++) {
+            const overlay = overlays[j];
+            const nextSegments = [];
+            for (let k = 0; k < segments.length; k++) {
+                const segment = segments[k];
+                const segmentStart = segment.start;
+                const segmentEnd = segment.start + segment.length;
+                const overlayStart = overlay.start;
+                const overlayEnd = overlay.start + overlay.length;
+                if (overlayEnd <= segmentStart || overlayStart >= segmentEnd) {
+                    nextSegments.push(segment);
+                    continue;
+                }
+                if (segmentStart < overlayStart) {
+                    nextSegments.push({
+                        start: segmentStart,
+                        length: overlayStart - segmentStart,
+                        classification: segment.classification,
+                    });
+                }
+                if (overlayEnd < segmentEnd) {
+                    nextSegments.push({
+                        start: overlayEnd,
+                        length: segmentEnd - overlayEnd,
+                        classification: segment.classification,
+                    });
+                }
+            }
+            segments = nextSegments;
+            if (segments.length === 0) {
+                break;
+            }
+        }
+        for (let j = 0; j < segments.length; j++) {
+            result.push(segments[j]);
+        }
+    }
+    return result;
+}
+function decodeSpans(spans) {
+    const decoded = [];
+    for (let i = 0; i + 2 < spans.length; i += 3) {
+        const start = spans[i];
+        const length = spans[i + 1];
+        const classification = spans[i + 2];
+        if (length <= 0) {
+            continue;
+        }
+        decoded.push({ start, length, classification });
+    }
+    return decoded;
+}
+function encodeSpans(spans) {
+    const encoded = [];
+    for (let i = 0; i < spans.length; i++) {
+        const span = spans[i];
+        encoded.push(span.start, span.length, span.classification);
+    }
+    return encoded;
+}
+function normalizeSpans(spans) {
+    if (spans.length === 0) {
+        return [];
+    }
+    const sorted = spans
+        .filter((span) => span.length > 0)
+        .slice()
+        .sort((left, right) => {
+        if (left.start !== right.start) {
+            return left.start - right.start;
+        }
+        if (left.length !== right.length) {
+            return left.length - right.length;
+        }
+        return left.classification - right.classification;
+    });
+    const normalized = [];
+    for (let i = 0; i < sorted.length; i++) {
+        const span = sorted[i];
+        const previous = normalized[normalized.length - 1];
+        if (previous &&
+            previous.start === span.start &&
+            previous.length === span.length &&
+            previous.classification === span.classification) {
+            continue;
+        }
+        normalized.push(span);
+    }
+    return normalized;
+}
+function uniqueTokens(tokens) {
+    if (tokens.length === 0) {
+        return [];
+    }
+    const map = new Map();
+    for (let i = 0; i < tokens.length; i++) {
+        const token = tokens[i];
+        const key = `${token.start}:${token.length}:${token.kind}`;
+        if (!map.has(key)) {
+            map.set(key, token);
+        }
+    }
+    return Array.from(map.values()).sort((left, right) => {
+        if (left.start !== right.start) {
+            return left.start - right.start;
+        }
+        return left.length - right.length;
+    });
+}

package/dist/quickinfo.d.ts

@@ -0,0 +1,3 @@
+import type tsModule from 'typescript/lib/tsserverlibrary';
+import type { FileAnalysis, ResolvedConfig } from './types';
+export declare function getKForQuickInfoAtPosition(analysis: FileAnalysis, position: number, ts: typeof tsModule, config: ResolvedConfig): tsModule.QuickInfo | undefined;

package/dist/quickinfo.js

@@ -0,0 +1,318 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getKForQuickInfoAtPosition = getKForQuickInfoAtPosition;
+const ast_1 = require("./ast");
+const completion_1 = require("./completion");
+const jsx_attributes_1 = require("./jsx-attributes");
+const identifiers_1 = require("./identifiers");
+const kfor_parser_1 = require("./kfor-parser");
+const scope_analysis_1 = require("./scope-analysis");
+const type_resolution_1 = require("./type-resolution");
+const IDENTIFIER_PATTERN = /[A-Za-z_$][A-Za-z0-9_$]*/g;
+const KEYWORD_DELIMITER_PATTERN = /\s+(in|of)\s+/;
+function getKForQuickInfoAtPosition(analysis, position, ts, config) {
+    const stringQuickInfo = getKForStringQuickInfo(analysis, position, ts, config);
+    if (stringQuickInfo) {
+        return stringQuickInfo;
+    }
+    const identifier = (0, ast_1.findIdentifierAtPosition)(analysis.sourceFile, position, ts);
+    if (!identifier) {
+        return undefined;
+    }
+    const bindings = (0, scope_analysis_1.collectBindingsAtPosition)(position, analysis.scopes);
+    if (bindings.size === 0) {
+        return undefined;
+    }
+    const aliasBinding = bindings.get(identifier.text);
+    if (aliasBinding) {
+        return createQuickInfo(identifier, `(k-for) ${aliasBinding.name}`, aliasBinding.types, analysis.checker, ts);
+    }
+    const memberTypes = resolveMemberQuickInfoTypes(identifier, bindings, analysis.sourceFile, analysis.checker, ts);
+    if (memberTypes.length > 0) {
+        return createQuickInfo(identifier, `(k-for) ${identifier.text}`, memberTypes, analysis.checker, ts);
+    }
+    return undefined;
+}
+function getKForStringQuickInfo(analysis, position, ts, config) {
+    const context = findKForStringContextAtPosition(analysis.sourceFile, position, ts, config);
+    if (!context) {
+        return undefined;
+    }
+    if (context.token.kind === 'alias') {
+        const bindings = (0, scope_analysis_1.resolveBindingsForForAttribute)(context.opening, context.attr, analysis.checker, config, ts);
+        for (let i = 0; i < bindings.length; i++) {
+            const binding = bindings[i];
+            if (binding.name === context.token.text) {
+                return createQuickInfoForSpan(context.token.start, context.token.length, `(k-for) ${binding.name}`, binding.types, analysis.checker, context.opening, ts);
+            }
+        }
+        return undefined;
+    }
+    if (context.token.kind === 'source') {
+        const expression = getSourceExpressionForToken(context, ts);
+        if (!expression) {
+            return undefined;
+        }
+        const types = (0, type_resolution_1.resolveExpressionTypesFromText)(expression, {
+            checker: analysis.checker,
+            ts,
+            scopeNode: context.opening,
+        });
+        if (types.length === 0) {
+            return undefined;
+        }
+        return createQuickInfoForSpan(context.token.start, context.token.length, `(k-for source) ${context.token.text}`, types, analysis.checker, context.opening, ts);
+    }
+    return undefined;
+}
+function resolveMemberQuickInfoTypes(identifier, bindings, sourceFile, checker, ts) {
+    const parent = identifier.parent;
+    let expressionText;
+    if (ts.isPropertyAccessExpression(parent) && parent.name === identifier) {
+        expressionText = parent.getText(sourceFile);
+    }
+    else if (ts.isElementAccessExpression(parent) && parent.argumentExpression === identifier) {
+        expressionText = parent.getText(sourceFile);
+    }
+    if (!expressionText) {
+        return [];
+    }
+    return (0, type_resolution_1.resolveExpressionTypesFromText)(expressionText, {
+        checker,
+        ts,
+        scopeNode: identifier,
+        localBindings: (0, completion_1.createBindingTypeMap)(bindings),
+    });
+}
+function findKForStringContextAtPosition(sourceFile, position, ts, config) {
+    let found;
+    const visit = (node) => {
+        if (found) {
+            return;
+        }
+        let opening;
+        if (ts.isJsxElement(node)) {
+            opening = node.openingElement;
+        }
+        else if (ts.isJsxSelfClosingElement(node)) {
+            opening = node;
+        }
+        if (opening) {
+            const attr = (0, jsx_attributes_1.getJsxAttribute)(opening, config.forAttr, ts);
+            if (attr) {
+                const tokenContext = findTokenInForAttribute(attr, opening, sourceFile, position, ts, config.allowOfKeyword);
+                if (tokenContext) {
+                    found = tokenContext;
+                    return;
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return found;
+}
+function findTokenInForAttribute(attr, opening, sourceFile, position, ts, allowOfKeyword) {
+    const content = getAttributeRawContent(attr, sourceFile, ts);
+    if (!content) {
+        return undefined;
+    }
+    const raw = content.text;
+    const rawStart = content.start;
+    if (position < rawStart || position >= rawStart + raw.length) {
+        return undefined;
+    }
+    const value = raw.trim();
+    if (!value) {
+        return undefined;
+    }
+    const parsed = (0, kfor_parser_1.parseKForExpression)(value, allowOfKeyword);
+    if (!parsed) {
+        return undefined;
+    }
+    const delimiterMatch = KEYWORD_DELIMITER_PATTERN.exec(value);
+    if (!delimiterMatch) {
+        return undefined;
+    }
+    const trimStart = raw.length - raw.trimStart().length;
+    const keyword = delimiterMatch[1];
+    const keywordOffsetInDelimiter = delimiterMatch[0].indexOf(keyword);
+    const leftSegment = value.slice(0, delimiterMatch.index);
+    const rightSegment = value.slice(delimiterMatch.index + delimiterMatch[0].length);
+    const leftLeading = leftSegment.length - leftSegment.trimStart().length;
+    const leftTrimmed = leftSegment.trim();
+    let aliasText = leftTrimmed;
+    let aliasStartInRaw = trimStart + leftLeading;
+    if (leftTrimmed.startsWith('(') && leftTrimmed.endsWith(')')) {
+        aliasText = leftTrimmed.slice(1, -1);
+        aliasStartInRaw += 1;
+    }
+    const rightLeading = rightSegment.length - rightSegment.trimStart().length;
+    const sourceText = rightSegment.trim();
+    const sourceStartInRaw = trimStart + delimiterMatch.index + delimiterMatch[0].length + rightLeading;
+    const aliasTokens = collectAliasTokens(aliasText, aliasStartInRaw, parsed.aliases, rawStart);
+    const sourceTokens = collectSourceTokens(sourceText, sourceStartInRaw, rawStart, ts);
+    const keywordToken = {
+        kind: 'keyword',
+        text: keyword,
+        start: rawStart + trimStart + delimiterMatch.index + keywordOffsetInDelimiter,
+        length: keyword.length,
+    };
+    const allTokens = [...aliasTokens, keywordToken, ...sourceTokens];
+    for (let i = 0; i < allTokens.length; i++) {
+        const token = allTokens[i];
+        if (position >= token.start && position < token.start + token.length) {
+            return {
+                opening,
+                attr,
+                sourceText,
+                sourceStart: rawStart + sourceStartInRaw,
+                token,
+            };
+        }
+    }
+    return undefined;
+}
+function collectAliasTokens(aliasText, aliasStartInRaw, aliases, rawStart) {
+    const result = [];
+    const allowed = new Set(aliases);
+    let match;
+    IDENTIFIER_PATTERN.lastIndex = 0;
+    while ((match = IDENTIFIER_PATTERN.exec(aliasText))) {
+        const name = match[0];
+        if (!allowed.has(name) || !(0, identifiers_1.isValidIdentifier)(name)) {
+            continue;
+        }
+        result.push({
+            kind: 'alias',
+            text: name,
+            start: rawStart + aliasStartInRaw + match.index,
+            length: name.length,
+        });
+    }
+    return result;
+}
+function collectSourceTokens(sourceText, sourceStartInRaw, rawStart, ts) {
+    const tokens = collectSourceTokensWithAst(sourceText, sourceStartInRaw, rawStart, ts);
+    if (tokens.length > 0) {
+        return tokens;
+    }
+    const result = [];
+    let match;
+    IDENTIFIER_PATTERN.lastIndex = 0;
+    while ((match = IDENTIFIER_PATTERN.exec(sourceText))) {
+        const name = match[0];
+        if (!(0, identifiers_1.isValidIdentifier)(name)) {
+            continue;
+        }
+        result.push({
+            kind: 'source',
+            text: name,
+            start: rawStart + sourceStartInRaw + match.index,
+            length: name.length,
+        });
+    }
+    return result;
+}
+function collectSourceTokensWithAst(sourceText, sourceStartInRaw, rawStart, ts) {
+    const snippet = `(${sourceText});`;
+    const tempSourceFile = ts.createSourceFile('__k_for_quickinfo.ts', snippet, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    if (tempSourceFile.statements.length === 0) {
+        return [];
+    }
+    const statement = tempSourceFile.statements[0];
+    if (!ts.isExpressionStatement(statement)) {
+        return [];
+    }
+    const tokens = [];
+    const visit = (node) => {
+        if (ts.isIdentifier(node) && (0, identifiers_1.isValidIdentifier)(node.text)) {
+            const start = node.getStart(tempSourceFile) - 1;
+            const length = node.getWidth(tempSourceFile);
+            if (start >= 0 && start + length <= sourceText.length) {
+                tokens.push({
+                    kind: 'source',
+                    text: node.text,
+                    start: rawStart + sourceStartInRaw + start,
+                    length,
+                });
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(statement.expression);
+    return uniqueSourceTokens(tokens);
+}
+function uniqueSourceTokens(tokens) {
+    const map = new Map();
+    for (let i = 0; i < tokens.length; i++) {
+        const token = tokens[i];
+        const key = `${token.start}:${token.length}:${token.text}`;
+        if (!map.has(key)) {
+            map.set(key, token);
+        }
+    }
+    return Array.from(map.values()).sort((left, right) => left.start - right.start);
+}
+function getSourceExpressionForToken(context, ts) {
+    const relativeStart = context.token.start - context.sourceStart;
+    if (relativeStart < 0 || relativeStart >= context.sourceText.length) {
+        return undefined;
+    }
+    const snippet = `(${context.sourceText});`;
+    const tempSourceFile = ts.createSourceFile('__k_for_quickinfo_resolve.ts', snippet, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const lookupPosition = relativeStart + 1;
+    const identifier = (0, ast_1.findIdentifierAtPosition)(tempSourceFile, lookupPosition, ts);
+    if (!identifier) {
+        return context.token.text;
+    }
+    if (ts.isPropertyAccessExpression(identifier.parent) && identifier.parent.name === identifier) {
+        return identifier.parent.getText(tempSourceFile);
+    }
+    if (ts.isElementAccessExpression(identifier.parent) && identifier.parent.argumentExpression === identifier) {
+        return identifier.parent.getText(tempSourceFile);
+    }
+    return identifier.getText(tempSourceFile);
+}
+function getAttributeRawContent(attr, sourceFile, ts) {
+    const initializer = attr.initializer;
+    if (!initializer) {
+        return undefined;
+    }
+    if (ts.isStringLiteral(initializer)) {
+        const quotedText = initializer.getText(sourceFile);
+        if (quotedText.length < 2) {
+            return undefined;
+        }
+        return {
+            start: initializer.getStart(sourceFile) + 1,
+            text: quotedText.slice(1, -1),
+        };
+    }
+    const expression = (0, jsx_attributes_1.getAttributeExpression)(attr, ts);
+    if (!expression || !ts.isStringLiteralLike(expression)) {
+        return undefined;
+    }
+    const quotedText = expression.getText(sourceFile);
+    if (quotedText.length < 2) {
+        return undefined;
+    }
+    return {
+        start: expression.getStart(sourceFile) + 1,
+        text: quotedText.slice(1, -1),
+    };
+}
+function createQuickInfo(identifier, label, types, checker, ts) {
+    if (types.length === 0) {
+        return undefined;
+    }
+    return createQuickInfoForSpan(identifier.getStart(), identifier.getWidth(), label, types, checker, identifier, ts);
+}
+function createQuickInfoForSpan(start, length, label, types, checker, scopeNode, ts) {
+    return {
+        kind: ts.ScriptElementKind.localVariableElement,
+        kindModifiers: '',
+        textSpan: { start, length },
+        displayParts: [{ text: `${label}: ${(0, type_resolution_1.formatTypeList)(types, checker, scopeNode, ts)}`, kind: 'text' }],
+    };
+}

package/dist/scope-analysis.d.ts

@@ -1,5 +1,6 @@
 import type tsModule from 'typescript/lib/tsserverlibrary';
-import type { FileAnalysis, KForBinding, KForScope, ResolvedConfig } from './types';
+import type { FileAnalysis, JsxOpeningLikeElement, KForBinding, KForScope, ResolvedConfig } from './types';
 export declare function getFileAnalysis(fileName: string, languageService: tsModule.LanguageService, ts: typeof tsModule, config: ResolvedConfig): FileAnalysis | undefined;
 export declare function isSuppressed(position: number, diagnosticName: string, scopes: KForScope[]): boolean;
 export declare function collectBindingsAtPosition(position: number, scopes: KForScope[]): Map<string, KForBinding>;
+export declare function resolveBindingsForForAttribute(opening: JsxOpeningLikeElement, forAttr: tsModule.JsxAttribute, checker: tsModule.TypeChecker, config: ResolvedConfig, ts: typeof tsModule): KForBinding[];

package/dist/scope-analysis.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getFileAnalysis = getFileAnalysis;
 exports.isSuppressed = isSuppressed;
 exports.collectBindingsAtPosition = collectBindingsAtPosition;
+exports.resolveBindingsForForAttribute = resolveBindingsForForAttribute;
 const jsx_attributes_1 = require("./jsx-attributes");
 const kfor_parser_1 = require("./kfor-parser");
 const identifiers_1 = require("./identifiers");
@@ -53,6 +54,9 @@ function collectBindingsAtPosition(position, scopes) {
     }
     return bindings;
 }
+function resolveBindingsForForAttribute(opening, forAttr, checker, config, ts) {
+    return resolveScopeBindings(opening, forAttr, checker, config, ts);
+}
 function collectKForScopes(sourceFile, checker, ts, config) {
     const scopes = [];
     const visit = (node) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ktjs/ts-plugin",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "TypeScript language service plugin for kt.js k-for scope names in TSX.",
   "type": "commonjs",
   "main": "./dist/index.js",