Microsoft/vscode
1
0
Fork 0
mirror of https://github.com/microsoft/vscode.git synced 2025-12-23 19:59:37 +00:00
Code Issues Packages Projects Releases Wiki Activity

auto-fixed prefer-const violation

Browse Source
This commit is contained in:
Johannes
2022-06-08 17:49:21 +02:00
parent aa23a0dbb7
commit 0656d21d11
862 changed files with 6489 additions and 6489 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
extensions/html-language-features/server/src/modes/cssMode.ts
View File

@@ -9,56 +9,56 @@ import { LanguageMode, Workspace, Color, TextDocument, Position, Range, Completi
import { HTMLDocumentRegions, CSS_STYLE_RULE } from './embeddedSupport';
export function getCSSMode(cssLanguageService: CSSLanguageService, documentRegions: LanguageModelCache<HTMLDocumentRegions>, workspace: Workspace): LanguageMode {
let embeddedCSSDocuments = getLanguageModelCache<TextDocument>(10, 60, document => documentRegions.get(document).getEmbeddedDocument('css'));
let cssStylesheets = getLanguageModelCache<Stylesheet>(10, 60, document => cssLanguageService.parseStylesheet(document));
const embeddedCSSDocuments = getLanguageModelCache<TextDocument>(10, 60, document => documentRegions.get(document).getEmbeddedDocument('css'));
const cssStylesheets = getLanguageModelCache<Stylesheet>(10, 60, document => cssLanguageService.parseStylesheet(document));
return {
getId() {
return 'css';
},
async doValidation(document: TextDocument, settings = workspace.settings) {
let embedded = embeddedCSSDocuments.get(document);
const embedded = embeddedCSSDocuments.get(document);
return (cssLanguageService.doValidation(embedded, cssStylesheets.get(embedded), settings && settings.css) as Diagnostic[]);
},
async doComplete(document: TextDocument, position: Position, documentContext: DocumentContext, _settings = workspace.settings) {
let embedded = embeddedCSSDocuments.get(document);
const embedded = embeddedCSSDocuments.get(document);
const stylesheet = cssStylesheets.get(embedded);
return cssLanguageService.doComplete2(embedded, position, stylesheet, documentContext, _settings?.css?.completion) || CompletionList.create();
},
async doHover(document: TextDocument, position: Position, settings = workspace.settings) {
let embedded = embeddedCSSDocuments.get(document);
const embedded = embeddedCSSDocuments.get(document);
return cssLanguageService.doHover(embedded, position, cssStylesheets.get(embedded), settings?.css?.hover);
},
async findDocumentHighlight(document: TextDocument, position: Position) {
let embedded = embeddedCSSDocuments.get(document);
const embedded = embeddedCSSDocuments.get(document);
return cssLanguageService.findDocumentHighlights(embedded, position, cssStylesheets.get(embedded));
},
async findDocumentSymbols(document: TextDocument) {
let embedded = embeddedCSSDocuments.get(document);
const embedded = embeddedCSSDocuments.get(document);
return cssLanguageService.findDocumentSymbols(embedded, cssStylesheets.get(embedded)).filter(s => s.name !== CSS_STYLE_RULE);
},
async findDefinition(document: TextDocument, position: Position) {
let embedded = embeddedCSSDocuments.get(document);
const embedded = embeddedCSSDocuments.get(document);
return cssLanguageService.findDefinition(embedded, position, cssStylesheets.get(embedded));
},
async findReferences(document: TextDocument, position: Position) {
let embedded = embeddedCSSDocuments.get(document);
const embedded = embeddedCSSDocuments.get(document);
return cssLanguageService.findReferences(embedded, position, cssStylesheets.get(embedded));
},
async findDocumentColors(document: TextDocument) {
let embedded = embeddedCSSDocuments.get(document);
const embedded = embeddedCSSDocuments.get(document);
return cssLanguageService.findDocumentColors(embedded, cssStylesheets.get(embedded));
},
async getColorPresentations(document: TextDocument, color: Color, range: Range) {
let embedded = embeddedCSSDocuments.get(document);
const embedded = embeddedCSSDocuments.get(document);
return cssLanguageService.getColorPresentations(embedded, cssStylesheets.get(embedded), color, range);
},
async getFoldingRanges(document: TextDocument) {
let embedded = embeddedCSSDocuments.get(document);
const embedded = embeddedCSSDocuments.get(document);
return cssLanguageService.getFoldingRanges(embedded, {});
},
async getSelectionRange(document: TextDocument, position: Position) {
let embedded = embeddedCSSDocuments.get(document);
const embedded = embeddedCSSDocuments.get(document);
return cssLanguageService.getSelectionRanges(embedded, [position], cssStylesheets.get(embedded))[0];
},
onDocumentRemoved(document: TextDocument) {

42
extensions/html-language-features/server/src/modes/embeddedSupport.ts
View File

@@ -24,12 +24,12 @@ interface EmbeddedRegion { languageId: string | undefined; start: number; end: n
export function getDocumentRegions(languageService: LanguageService, document: TextDocument): HTMLDocumentRegions {
let regions: EmbeddedRegion[] = [];
let scanner = languageService.createScanner(document.getText());
const regions: EmbeddedRegion[] = [];
const scanner = languageService.createScanner(document.getText());
let lastTagName: string = '';
let lastAttributeName: string | null = null;
let languageIdFromType: string | undefined = undefined;
let importedScripts: string[] = [];
const importedScripts: string[] = [];
let token = scanner.scan();
while (token !== TokenType.EOS) {
@@ -64,11 +64,11 @@ export function getDocumentRegions(languageService: LanguageService, document: T
languageIdFromType = undefined;
}
} else {
let attributeLanguageId = getAttributeLanguage(lastAttributeName!);
const attributeLanguageId = getAttributeLanguage(lastAttributeName!);
if (attributeLanguageId) {
let start = scanner.getTokenOffset();
let end = scanner.getTokenEnd();
let firstChar = document.getText()[start];
const firstChar = document.getText()[start];
if (firstChar === '\'' || firstChar === '"') {
start++;
end--;
@@ -92,14 +92,14 @@ export function getDocumentRegions(languageService: LanguageService, document: T
function getLanguageRanges(document: TextDocument, regions: EmbeddedRegion[], range: Range): LanguageRange[] {
let result: LanguageRange[] = [];
const result: LanguageRange[] = [];
let currentPos = range ? range.start : Position.create(0, 0);
let currentOffset = range ? document.offsetAt(range.start) : 0;
let endOffset = range ? document.offsetAt(range.end) : document.getText().length;
for (let region of regions) {
const endOffset = range ? document.offsetAt(range.end) : document.getText().length;
for (const region of regions) {
if (region.end > currentOffset && region.start < endOffset) {
let start = Math.max(region.start, currentOffset);
let startPos = document.positionAt(start);
const start = Math.max(region.start, currentOffset);
const startPos = document.positionAt(start);
if (currentOffset < region.start) {
result.push({
start: currentPos,
@@ -107,8 +107,8 @@ function getLanguageRanges(document: TextDocument, regions: EmbeddedRegion[], ra
languageId: 'html'
});
}
let end = Math.min(region.end, endOffset);
let endPos = document.positionAt(end);
const end = Math.min(region.end, endOffset);
const endPos = document.positionAt(end);
if (end > region.start) {
result.push({
start: startPos,
@@ -122,7 +122,7 @@ function getLanguageRanges(document: TextDocument, regions: EmbeddedRegion[], ra
}
}
if (currentOffset < endOffset) {
let endPos = range ? range.end : document.positionAt(endOffset);
const endPos = range ? range.end : document.positionAt(endOffset);
result.push({
start: currentPos,
end: endPos,
@@ -133,8 +133,8 @@ function getLanguageRanges(document: TextDocument, regions: EmbeddedRegion[], ra
}
function getLanguagesInDocument(_document: TextDocument, regions: EmbeddedRegion[]): string[] {
let result = [];
for (let region of regions) {
const result = [];
for (const region of regions) {
if (region.languageId && result.indexOf(region.languageId) === -1) {
result.push(region.languageId);
if (result.length === 3) {
@@ -147,8 +147,8 @@ function getLanguagesInDocument(_document: TextDocument, regions: EmbeddedRegion
}
function getLanguageAtPosition(document: TextDocument, regions: EmbeddedRegion[], position: Position): string | undefined {
let offset = document.offsetAt(position);
for (let region of regions) {
const offset = document.offsetAt(position);
for (const region of regions) {
if (region.start <= offset) {
if (offset <= region.end) {
return region.languageId;
@@ -162,10 +162,10 @@ function getLanguageAtPosition(document: TextDocument, regions: EmbeddedRegion[]
function getEmbeddedDocument(document: TextDocument, contents: EmbeddedRegion[], languageId: string, ignoreAttributeValues: boolean): TextDocument {
let currentPos = 0;
let oldContent = document.getText();
const oldContent = document.getText();
let result = '';
let lastSuffix = '';
for (let c of contents) {
for (const c of contents) {
if (c.languageId === languageId && (!ignoreAttributeValues || !c.attributeValue)) {
result = substituteWithWhitespace(result, currentPos, c.start, oldContent, lastSuffix, getPrefix(c));
result += oldContent.substring(c.start, c.end);
@@ -199,7 +199,7 @@ function substituteWithWhitespace(result: string, start: number, end: number, ol
let accumulatedWS = 0;
result += before;
for (let i = start + before.length; i < end; i++) {
let ch = oldContent[i];
const ch = oldContent[i];
if (ch === '\n' || ch === '\r') {
// only write new lines, skip the whitespace
accumulatedWS = 0;
@@ -225,7 +225,7 @@ function append(result: string, str: string, n: number): string {
}
function getAttributeLanguage(attributeName: string): string | null {
let match = attributeName.match(/^(style)$|^(on\w+)$/i);
const match = attributeName.match(/^(style)$|^(on\w+)$/i);
if (!match) {
return null;
}

44
extensions/html-language-features/server/src/modes/formatting.ts
View File

@@ -8,14 +8,14 @@ import { pushAll } from '../utils/arrays';
import { isEOL } from '../utils/strings';
export async function format(languageModes: LanguageModes, document: TextDocument, formatRange: Range, formattingOptions: FormattingOptions, settings: Settings | undefined, enabledModes: { [mode: string]: boolean }) {
let result: TextEdit[] = [];
const result: TextEdit[] = [];
let endPos = formatRange.end;
const endPos = formatRange.end;
let endOffset = document.offsetAt(endPos);
let content = document.getText();
const content = document.getText();
if (endPos.character === 0 && endPos.line > 0 && endOffset !== content.length) {
// if selection ends after a new line, exclude that new line
let prevLineStart = document.offsetAt(Position.create(endPos.line - 1, 0));
const prevLineStart = document.offsetAt(Position.create(endPos.line - 1, 0));
while (isEOL(content, endOffset - 1) && endOffset > prevLineStart) {
endOffset--;
}
@@ -31,15 +31,15 @@ export async function format(languageModes: LanguageModes, document: TextDocumen
// - no worrying of overlapping edits
// make sure we start in html
let allRanges = languageModes.getModesInRange(document, formatRange);
const allRanges = languageModes.getModesInRange(document, formatRange);
let i = 0;
let startPos = formatRange.start;
let isHTML = (range: LanguageModeRange) => range.mode && range.mode.getId() === 'html';
const isHTML = (range: LanguageModeRange) => range.mode && range.mode.getId() === 'html';
while (i < allRanges.length && !isHTML(allRanges[i])) {
let range = allRanges[i];
const range = allRanges[i];
if (!range.attributeValue && range.mode && range.mode.format) {
let edits = await range.mode.format(document, Range.create(startPos, range.end), formattingOptions, settings);
const edits = await range.mode.format(document, Range.create(startPos, range.end), formattingOptions, settings);
pushAll(result, edits);
}
startPos = range.end;
@@ -52,23 +52,23 @@ export async function format(languageModes: LanguageModes, document: TextDocumen
formatRange = Range.create(startPos, formatRange.end);
// perform a html format and apply changes to a new document
let htmlMode = languageModes.getMode('html')!;
let htmlEdits = await htmlMode.format!(document, formatRange, formattingOptions, settings);
let htmlFormattedContent = TextDocument.applyEdits(document, htmlEdits);
let newDocument = TextDocument.create(document.uri + '.tmp', document.languageId, document.version, htmlFormattedContent);
const htmlMode = languageModes.getMode('html')!;
const htmlEdits = await htmlMode.format!(document, formatRange, formattingOptions, settings);
const htmlFormattedContent = TextDocument.applyEdits(document, htmlEdits);
const newDocument = TextDocument.create(document.uri + '.tmp', document.languageId, document.version, htmlFormattedContent);
try {
// run embedded formatters on html formatted content: - formatters see correct initial indent
let afterFormatRangeLength = document.getText().length - document.offsetAt(formatRange.end); // length of unchanged content after replace range
let newFormatRange = Range.create(formatRange.start, newDocument.positionAt(htmlFormattedContent.length - afterFormatRangeLength));
let embeddedRanges = languageModes.getModesInRange(newDocument, newFormatRange);
const afterFormatRangeLength = document.getText().length - document.offsetAt(formatRange.end); // length of unchanged content after replace range
const newFormatRange = Range.create(formatRange.start, newDocument.positionAt(htmlFormattedContent.length - afterFormatRangeLength));
const embeddedRanges = languageModes.getModesInRange(newDocument, newFormatRange);
let embeddedEdits: TextEdit[] = [];
const embeddedEdits: TextEdit[] = [];
for (let r of embeddedRanges) {
let mode = r.mode;
for (const r of embeddedRanges) {
const mode = r.mode;
if (mode && mode.format && enabledModes[mode.getId()] && !r.attributeValue) {
let edits = await mode.format(newDocument, r, formattingOptions, settings);
for (let edit of edits) {
const edits = await mode.format(newDocument, r, formattingOptions, settings);
for (const edit of edits) {
embeddedEdits.push(edit);
}
}
@@ -80,8 +80,8 @@ export async function format(languageModes: LanguageModes, document: TextDocumen
}
// apply all embedded format edits and create a single edit for all changes
let resultContent = TextDocument.applyEdits(newDocument, embeddedEdits);
let resultReplaceText = resultContent.substring(document.offsetAt(formatRange.start), resultContent.length - afterFormatRangeLength);
const resultContent = TextDocument.applyEdits(newDocument, embeddedEdits);
const resultReplaceText = resultContent.substring(document.offsetAt(formatRange.start), resultContent.length - afterFormatRangeLength);
result.push(TextEdit.replace(formatRange, resultReplaceText));
return result;

30
extensions/html-language-features/server/src/modes/htmlFolding.ts
View File

@@ -7,16 +7,16 @@ import { TextDocument, FoldingRange, Position, Range, LanguageModes, LanguageMod
import { CancellationToken } from 'vscode-languageserver';
export async function getFoldingRanges(languageModes: LanguageModes, document: TextDocument, maxRanges: number | undefined, _cancellationToken: CancellationToken | null): Promise<FoldingRange[]> {
let htmlMode = languageModes.getMode('html');
let range = Range.create(Position.create(0, 0), Position.create(document.lineCount, 0));
const htmlMode = languageModes.getMode('html');
const range = Range.create(Position.create(0, 0), Position.create(document.lineCount, 0));
let result: FoldingRange[] = [];
if (htmlMode && htmlMode.getFoldingRanges) {
result.push(... await htmlMode.getFoldingRanges(document));
}
// cache folding ranges per mode
let rangesPerMode: { [mode: string]: FoldingRange[] } = Object.create(null);
let getRangesForMode = async (mode: LanguageMode) => {
const rangesPerMode: { [mode: string]: FoldingRange[] } = Object.create(null);
const getRangesForMode = async (mode: LanguageMode) => {
if (mode.getFoldingRanges) {
let ranges = rangesPerMode[mode.getId()];
if (!Array.isArray(ranges)) {
@@ -28,9 +28,9 @@ export async function getFoldingRanges(languageModes: LanguageModes, document: T
return [];
};
let modeRanges = languageModes.getModesInRange(document, range);
for (let modeRange of modeRanges) {
let mode = modeRange.mode;
const modeRanges = languageModes.getModesInRange(document, range);
for (const modeRange of modeRanges) {
const mode = modeRange.mode;
if (mode && mode !== htmlMode && !modeRange.attributeValue) {
const ranges = await getRangesForMode(mode);
result.push(...ranges.filter(r => r.startLine >= modeRange.start.line && r.endLine < modeRange.end.line));
@@ -54,11 +54,11 @@ function limitRanges(ranges: FoldingRange[], maxRanges: number) {
// compute each range's nesting level in 'nestingLevels'.
// count the number of ranges for each level in 'nestingLevelCounts'
let top: FoldingRange | undefined = undefined;
let previous: FoldingRange[] = [];
let nestingLevels: number[] = [];
let nestingLevelCounts: number[] = [];
const previous: FoldingRange[] = [];
const nestingLevels: number[] = [];
const nestingLevelCounts: number[] = [];
let setNestingLevel = (index: number, level: number) => {
const setNestingLevel = (index: number, level: number) => {
nestingLevels[index] = level;
if (level < 30) {
nestingLevelCounts[level] = (nestingLevelCounts[level] || 0) + 1;
@@ -67,7 +67,7 @@ function limitRanges(ranges: FoldingRange[], maxRanges: number) {
// compute nesting levels and sanitize
for (let i = 0; i < ranges.length; i++) {
let entry = ranges[i];
const entry = ranges[i];
if (!top) {
top = entry;
setNestingLevel(i, 0);
@@ -93,7 +93,7 @@ function limitRanges(ranges: FoldingRange[], maxRanges: number) {
let entries = 0;
let maxLevel = 0;
for (let i = 0; i < nestingLevelCounts.length; i++) {
let n = nestingLevelCounts[i];
const n = nestingLevelCounts[i];
if (n) {
if (n + entries > maxRanges) {
maxLevel = i;
@@ -102,9 +102,9 @@ function limitRanges(ranges: FoldingRange[], maxRanges: number) {
entries += n;
}
}
let result = [];
const result = [];
for (let i = 0; i < ranges.length; i++) {
let level = nestingLevels[i];
const level = nestingLevels[i];
if (typeof level === 'number') {
if (level < maxLevel || (level === maxLevel && entries++ < maxRanges)) {
result.push(ranges[i]);

80
extensions/html-language-features/server/src/modes/javascriptMode.ts
View File

@@ -95,10 +95,10 @@ function getLanguageServiceHost(scriptKind: ts.ScriptKind) {
export function getJavaScriptMode(documentRegions: LanguageModelCache<HTMLDocumentRegions>, languageId: 'javascript' | 'typescript', workspace: Workspace): LanguageMode {
let jsDocuments = getLanguageModelCache<TextDocument>(10, 60, document => documentRegions.get(document).getEmbeddedDocument(languageId));
const jsDocuments = getLanguageModelCache<TextDocument>(10, 60, document => documentRegions.get(document).getEmbeddedDocument(languageId));
const host = getLanguageServiceHost(languageId === 'javascript' ? ts.ScriptKind.JS : ts.ScriptKind.TS);
let globalSettings: Settings = {};
const globalSettings: Settings = {};
return {
getId() {
@@ -122,12 +122,12 @@ export function getJavaScriptMode(documentRegions: LanguageModelCache<HTMLDocume
async doComplete(document: TextDocument, position: Position, _documentContext: DocumentContext): Promise<CompletionList> {
const jsDocument = jsDocuments.get(document);
const jsLanguageService = await host.getLanguageService(jsDocument);
let offset = jsDocument.offsetAt(position);
let completions = jsLanguageService.getCompletionsAtPosition(jsDocument.uri, offset, { includeExternalModuleExports: false, includeInsertTextCompletions: false });
const offset = jsDocument.offsetAt(position);
const completions = jsLanguageService.getCompletionsAtPosition(jsDocument.uri, offset, { includeExternalModuleExports: false, includeInsertTextCompletions: false });
if (!completions) {
return { isIncomplete: false, items: [] };
}
let replaceRange = convertRange(jsDocument, getWordAtText(jsDocument.getText(), offset, JS_WORD_REGEX));
const replaceRange = convertRange(jsDocument, getWordAtText(jsDocument.getText(), offset, JS_WORD_REGEX));
return {
isIncomplete: false,
items: completions.entries.map(entry => {
@@ -152,7 +152,7 @@ export function getJavaScriptMode(documentRegions: LanguageModelCache<HTMLDocume
if (isCompletionItemData(item.data)) {
const jsDocument = jsDocuments.get(document);
const jsLanguageService = await host.getLanguageService(jsDocument);
let details = jsLanguageService.getCompletionEntryDetails(jsDocument.uri, item.data.offset, item.label, undefined, undefined, undefined, undefined);
const details = jsLanguageService.getCompletionEntryDetails(jsDocument.uri, item.data.offset, item.label, undefined, undefined, undefined, undefined);
if (details) {
item.detail = ts.displayPartsToString(details.displayParts);
item.documentation = ts.displayPartsToString(details.documentation);
@@ -164,7 +164,7 @@ export function getJavaScriptMode(documentRegions: LanguageModelCache<HTMLDocume
async doHover(document: TextDocument, position: Position): Promise<Hover | null> {
const jsDocument = jsDocuments.get(document);
const jsLanguageService = await host.getLanguageService(jsDocument);
let info = jsLanguageService.getQuickInfoAtPosition(jsDocument.uri, jsDocument.offsetAt(position));
const info = jsLanguageService.getQuickInfoAtPosition(jsDocument.uri, jsDocument.offsetAt(position));
if (info) {
const contents = ts.displayPartsToString(info.displayParts);
return {
@@ -177,16 +177,16 @@ export function getJavaScriptMode(documentRegions: LanguageModelCache<HTMLDocume
async doSignatureHelp(document: TextDocument, position: Position): Promise<SignatureHelp | null> {
const jsDocument = jsDocuments.get(document);
const jsLanguageService = await host.getLanguageService(jsDocument);
let signHelp = jsLanguageService.getSignatureHelpItems(jsDocument.uri, jsDocument.offsetAt(position), undefined);
const signHelp = jsLanguageService.getSignatureHelpItems(jsDocument.uri, jsDocument.offsetAt(position), undefined);
if (signHelp) {
let ret: SignatureHelp = {
const ret: SignatureHelp = {
activeSignature: signHelp.selectedItemIndex,
activeParameter: signHelp.argumentIndex,
signatures: []
};
signHelp.items.forEach(item => {
let signature: SignatureInformation = {
const signature: SignatureInformation = {
label: '',
documentation: undefined,
parameters: []
@@ -194,8 +194,8 @@ export function getJavaScriptMode(documentRegions: LanguageModelCache<HTMLDocume
signature.label += ts.displayPartsToString(item.prefixDisplayParts);
item.parameters.forEach((p, i, a) => {
let label = ts.displayPartsToString(p.displayParts);
let parameter: ParameterInformation = {
const label = ts.displayPartsToString(p.displayParts);
const parameter: ParameterInformation = {
label: label,
documentation: ts.displayPartsToString(p.documentation)
};
@@ -252,14 +252,14 @@ export function getJavaScriptMode(documentRegions: LanguageModelCache<HTMLDocume
async findDocumentSymbols(document: TextDocument): Promise<SymbolInformation[]> {
const jsDocument = jsDocuments.get(document);
const jsLanguageService = await host.getLanguageService(jsDocument);
let items = jsLanguageService.getNavigationBarItems(jsDocument.uri);
const items = jsLanguageService.getNavigationBarItems(jsDocument.uri);
if (items) {
let result: SymbolInformation[] = [];
let existing = Object.create(null);
let collectSymbols = (item: ts.NavigationBarItem, containerLabel?: string) => {
let sig = item.text + item.kind + item.spans[0].start;
const result: SymbolInformation[] = [];
const existing = Object.create(null);
const collectSymbols = (item: ts.NavigationBarItem, containerLabel?: string) => {
const sig = item.text + item.kind + item.spans[0].start;
if (item.kind !== 'script' && !existing[sig]) {
let symbol: SymbolInformation = {
const symbol: SymbolInformation = {
name: item.text,
kind: convertSymbolKind(item.kind),
location: {
@@ -274,7 +274,7 @@ export function getJavaScriptMode(documentRegions: LanguageModelCache<HTMLDocume
}
if (item.childItems && item.childItems.length > 0) {
for (let child of item.childItems) {
for (const child of item.childItems) {
collectSymbols(child, containerLabel);
}
}
@@ -289,7 +289,7 @@ export function getJavaScriptMode(documentRegions: LanguageModelCache<HTMLDocume
async findDefinition(document: TextDocument, position: Position): Promise<Definition | null> {
const jsDocument = jsDocuments.get(document);
const jsLanguageService = await host.getLanguageService(jsDocument);
let definition = jsLanguageService.getDefinitionAtPosition(jsDocument.uri, jsDocument.offsetAt(position));
const definition = jsLanguageService.getDefinitionAtPosition(jsDocument.uri, jsDocument.offsetAt(position));
if (definition) {
return definition.filter(d => d.fileName === jsDocument.uri).map(d => {
return {
@@ -303,7 +303,7 @@ export function getJavaScriptMode(documentRegions: LanguageModelCache<HTMLDocume
async findReferences(document: TextDocument, position: Position): Promise<Location[]> {
const jsDocument = jsDocuments.get(document);
const jsLanguageService = await host.getLanguageService(jsDocument);
let references = jsLanguageService.getReferencesAtPosition(jsDocument.uri, jsDocument.offsetAt(position));
const references = jsLanguageService.getReferencesAtPosition(jsDocument.uri, jsDocument.offsetAt(position));
if (references) {
return references.filter(d => d.fileName === jsDocument.uri).map(d => {
return {
@@ -328,21 +328,21 @@ export function getJavaScriptMode(documentRegions: LanguageModelCache<HTMLDocume
const jsDocument = documentRegions.get(document).getEmbeddedDocument('javascript', true);
const jsLanguageService = await host.getLanguageService(jsDocument);
let formatterSettings = settings && settings.javascript && settings.javascript.format;
const formatterSettings = settings && settings.javascript && settings.javascript.format;
let initialIndentLevel = computeInitialIndent(document, range, formatParams);
let formatSettings = convertOptions(formatParams, formatterSettings, initialIndentLevel + 1);
let start = jsDocument.offsetAt(range.start);
const initialIndentLevel = computeInitialIndent(document, range, formatParams);
const formatSettings = convertOptions(formatParams, formatterSettings, initialIndentLevel + 1);
const start = jsDocument.offsetAt(range.start);
let end = jsDocument.offsetAt(range.end);
let lastLineRange = null;
if (range.end.line > range.start.line && (range.end.character === 0 || isWhitespaceOnly(jsDocument.getText().substr(end - range.end.character, range.end.character)))) {
end -= range.end.character;
lastLineRange = Range.create(Position.create(range.end.line, 0), range.end);
}
let edits = jsLanguageService.getFormattingEditsForRange(jsDocument.uri, start, end, formatSettings);
const edits = jsLanguageService.getFormattingEditsForRange(jsDocument.uri, start, end, formatSettings);
if (edits) {
let result = [];
for (let edit of edits) {
const result = [];
for (const edit of edits) {
if (edit.span.start >= start && edit.span.start + edit.span.length <= end) {
result.push({
range: convertRange(jsDocument, edit.span),
@@ -363,15 +363,15 @@ export function getJavaScriptMode(documentRegions: LanguageModelCache<HTMLDocume
async getFoldingRanges(document: TextDocument): Promise<FoldingRange[]> {
const jsDocument = jsDocuments.get(document);
const jsLanguageService = await host.getLanguageService(jsDocument);
let spans = jsLanguageService.getOutliningSpans(jsDocument.uri);
let ranges: FoldingRange[] = [];
for (let span of spans) {
let curr = convertRange(jsDocument, span.textSpan);
let startLine = curr.start.line;
let endLine = curr.end.line;
const spans = jsLanguageService.getOutliningSpans(jsDocument.uri);
const ranges: FoldingRange[] = [];
for (const span of spans) {
const curr = convertRange(jsDocument, span.textSpan);
const startLine = curr.start.line;
const endLine = curr.end.line;
if (startLine < endLine) {
let foldingRange: FoldingRange = { startLine, endLine };
let match = document.getText(curr).match(/^\s*\/(?:(\/\s*#(?:end)?region\b)|(\*|\/))/);
const foldingRange: FoldingRange = { startLine, endLine };
const match = document.getText(curr).match(/^\s*\/(?:(\/\s*#(?:end)?region\b)|(\*|\/))/);
if (match) {
foldingRange.kind = match[1] ? FoldingRangeKind.Region : FoldingRangeKind.Comment;
}
@@ -563,14 +563,14 @@ function convertOptions(options: FormattingOptions, formatSettings: any, initial
}
function computeInitialIndent(document: TextDocument, range: Range, options: FormattingOptions) {
let lineStart = document.offsetAt(Position.create(range.start.line, 0));
let content = document.getText();
const lineStart = document.offsetAt(Position.create(range.start.line, 0));
const content = document.getText();
let i = lineStart;
let nChars = 0;
let tabSize = options.tabSize || 4;
const tabSize = options.tabSize || 4;
while (i < content.length) {
let ch = content.charAt(i);
const ch = content.charAt(i);
if (ch === ' ') {
nChars++;
} else if (ch === '\t') {

20
extensions/html-language-features/server/src/modes/languageModes.ts
View File

@@ -111,7 +111,7 @@ export function getLanguageModes(supportedLanguages: { [languageId: string]: boo
const htmlLanguageService = getHTMLLanguageService({ clientCapabilities, fileSystemProvider: requestService });
const cssLanguageService = getCSSLanguageService({ clientCapabilities, fileSystemProvider: requestService });
let documentRegions = getLanguageModelCache<HTMLDocumentRegions>(10, 60, document => getDocumentRegions(htmlLanguageService, document));
const documentRegions = getLanguageModelCache<HTMLDocumentRegions>(10, 60, document => getDocumentRegions(htmlLanguageService, document));
let modelCaches: LanguageModelCache<any>[] = [];
modelCaches.push(documentRegions);
@@ -130,7 +130,7 @@ export function getLanguageModes(supportedLanguages: { [languageId: string]: boo
htmlLanguageService.setDataProviders(true, dataProviders);
},
getModeAtPosition(document: TextDocument, position: Position): LanguageMode | undefined {
let languageId = documentRegions.get(document).getLanguageAtPosition(position);
const languageId = documentRegions.get(document).getLanguageAtPosition(position);
if (languageId) {
return modes[languageId];
}
@@ -147,9 +147,9 @@ export function getLanguageModes(supportedLanguages: { [languageId: string]: boo
});
},
getAllModesInDocument(document: TextDocument): LanguageMode[] {
let result = [];
for (let languageId of documentRegions.get(document).getLanguagesInDocument()) {
let mode = modes[languageId];
const result = [];
for (const languageId of documentRegions.get(document).getLanguagesInDocument()) {
const mode = modes[languageId];
if (mode) {
result.push(mode);
}
@@ -157,9 +157,9 @@ export function getLanguageModes(supportedLanguages: { [languageId: string]: boo
return result;
},
getAllModes(): LanguageMode[] {
let result = [];
for (let languageId in modes) {
let mode = modes[languageId];
const result = [];
for (const languageId in modes) {
const mode = modes[languageId];
if (mode) {
result.push(mode);
}
@@ -171,14 +171,14 @@ export function getLanguageModes(supportedLanguages: { [languageId: string]: boo
},
onDocumentRemoved(document: TextDocument) {
modelCaches.forEach(mc => mc.onDocumentRemoved(document));
for (let mode in modes) {
for (const mode in modes) {
modes[mode].onDocumentRemoved(document);
}
},
dispose(): void {
modelCaches.forEach(mc => mc.dispose());
modelCaches = [];
for (let mode in modes) {
for (const mode in modes) {
modes[mode].dispose();
}
modes = {};

2
extensions/html-language-features/server/src/modes/selectionRanges.ts
View File

@@ -12,7 +12,7 @@ export async function getSelectionRanges(languageModes: LanguageModes, document:
const htmlRange = await htmlMode!.getSelectionRange!(document, position);
const mode = languageModes.getModeAtPosition(document, position);
if (mode && mode.getSelectionRange) {
let range = await mode.getSelectionRange(document, position);
const range = await mode.getSelectionRange(document, position);
let top = range;
while (top.parent && insideRangeButNotSame(htmlRange.range, top.parent.range)) {
top = top.parent;

12
extensions/html-language-features/server/src/modes/semanticTokens.ts
View File

@@ -23,7 +23,7 @@ export function newSemanticTokenProvider(languageModes: LanguageModes): Semantic
const legend: { types: string[]; modifiers: string[] } = { types: [], modifiers: [] };
const legendMappings: { [modeId: string]: LegendMapping } = {};
for (let mode of languageModes.getAllModes()) {
for (const mode of languageModes.getAllModes()) {
if (mode.getSemanticTokenLegend && mode.getSemanticTokens) {
const modeLegend = mode.getSemanticTokenLegend();
legendMappings[mode.getId()] = { types: createMapping(modeLegend.types, legend.types), modifiers: createMapping(modeLegend.modifiers, legend.modifiers) };
@@ -34,13 +34,13 @@ export function newSemanticTokenProvider(languageModes: LanguageModes): Semantic
legend,
async getSemanticTokens(document: TextDocument, ranges?: Range[]): Promise<number[]> {
const allTokens: SemanticTokenData[] = [];
for (let mode of languageModes.getAllModesInDocument(document)) {
for (const mode of languageModes.getAllModesInDocument(document)) {
if (mode.getSemanticTokens) {
const mapping = legendMappings[mode.getId()];
const tokens = await mode.getSemanticTokens(document);
applyTypesMapping(tokens, mapping.types);
applyModifiersMapping(tokens, mapping.modifiers);
for (let token of tokens) {
for (const token of tokens) {
allTokens.push(token);
}
}
@@ -68,7 +68,7 @@ function createMapping(origLegend: string[], newLegend: string[]): number[] | un
function applyTypesMapping(tokens: SemanticTokenData[], typesMapping: number[] | undefined): void {
if (typesMapping) {
for (let token of tokens) {
for (const token of tokens) {
token.typeIdx = typesMapping[token.typeIdx];
}
}
@@ -76,7 +76,7 @@ function applyTypesMapping(tokens: SemanticTokenData[], typesMapping: number[] |
function applyModifiersMapping(tokens: SemanticTokenData[], modifiersMapping: number[] | undefined): void {
if (modifiersMapping) {
for (let token of tokens) {
for (const token of tokens) {
let modifierSet = token.modifierSet;
if (modifierSet) {
let index = 0;
@@ -109,7 +109,7 @@ function encodeTokens(tokens: SemanticTokenData[], ranges: Range[] | undefined,
let prefLine = 0;
let prevChar = 0;
let encodedResult: number[] = [];
const encodedResult: number[] = [];
for (let k = 0; k < resultTokens.length && currRange; k++) {
const curr = resultTokens[k];