Microsoft/vscode
1
0
Fork 0
mirror of https://github.com/microsoft/vscode.git synced 2025-12-24 12:19:20 +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];

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

@@ -149,7 +149,7 @@ export function normalizePath(parts: string[]): string {
export function joinPath(uriString: string, ...paths: string[]): string {
const uri = URI.parse(uriString);
const parts = uri.path.split('/');
for (let path of paths) {
for (const path of paths) {
parts.push(...path.split('/'));
}
return uri.with({ path: normalizePath(parts) }).toString();

16
extensions/html-language-features/server/src/test/completions.test.ts
View File

@@ -19,7 +19,7 @@ export interface ItemDescription {
}
export function assertCompletion(completions: CompletionList, expected: ItemDescription, document: TextDocument) {
let matches = completions.items.filter(completion => {
const matches = completions.items.filter(completion => {
return completion.label === expected.label;
});
if (expected.notAvailable) {
@@ -28,7 +28,7 @@ export function assertCompletion(completions: CompletionList, expected: ItemDesc
}
assert.strictEqual(matches.length, 1, `${expected.label} should only existing once: Actual: ${completions.items.map(c => c.label).join(', ')}`);
let match = matches[0];
const match = matches[0];
if (expected.documentation) {
assert.strictEqual(match.documentation, expected.documentation);
}
@@ -47,28 +47,28 @@ export function assertCompletion(completions: CompletionList, expected: ItemDesc
const testUri = 'test://test/test.html';
export async function testCompletionFor(value: string, expected: { count?: number; items?: ItemDescription[] }, uri = testUri, workspaceFolders?: WorkspaceFolder[]): Promise<void> {
let offset = value.indexOf('|');
const offset = value.indexOf('|');
value = value.substr(0, offset) + value.substr(offset + 1);
let workspace = {
const workspace = {
settings: {},
folders: workspaceFolders || [{ name: 'x', uri: uri.substr(0, uri.lastIndexOf('/')) }]
};
let document = TextDocument.create(uri, 'html', 0, value);
let position = document.positionAt(offset);
const document = TextDocument.create(uri, 'html', 0, value);
const position = document.positionAt(offset);
const context = getDocumentContext(uri, workspace.folders);
const languageModes = getLanguageModes({ css: true, javascript: true }, workspace, ClientCapabilities.LATEST, getNodeFileFS());
const mode = languageModes.getModeAtPosition(document, position)!;
let list = await mode.doComplete!(document, position, context);
const list = await mode.doComplete!(document, position, context);
if (expected.count) {
assert.strictEqual(list.items.length, expected.count);
}
if (expected.items) {
for (let item of expected.items) {
for (const item of expected.items) {
assertCompletion(list, item, document);
}
}

2
extensions/html-language-features/server/src/test/documentContext.test.ts
View File

@@ -11,7 +11,7 @@ suite('HTML Document Context', () => {
const docURI = 'file:///users/test/folder/test.html';
const rootFolders = [{ name: '', uri: 'file:///users/test/' }];
let context = getDocumentContext(docURI, rootFolders);
const context = getDocumentContext(docURI, rootFolders);
assert.strictEqual(context.resolveReference('/', docURI), 'file:///users/test/');
assert.strictEqual(context.resolveReference('/message.html', docURI), 'file:///users/test/message.html');
assert.strictEqual(context.resolveReference('message.html', docURI), 'file:///users/test/folder/message.html');

18
extensions/html-language-features/server/src/test/formatting.test.ts
View File

@@ -15,7 +15,7 @@ import { getNodeFileFS } from '../node/nodeFs';
suite('HTML Embedded Formatting', () => {
async function assertFormat(value: string, expected: string, options?: any, formatOptions?: FormattingOptions, message?: string): Promise<void> {
let workspace = {
const workspace = {
settings: options,
folders: [{ name: 'foo', uri: 'test://foo' }]
};
@@ -32,21 +32,21 @@ suite('HTML Embedded Formatting', () => {
rangeStartOffset = 0;
rangeEndOffset = value.length;
}
let document = TextDocument.create('test://test/test.html', 'html', 0, value);
let range = Range.create(document.positionAt(rangeStartOffset), document.positionAt(rangeEndOffset));
const document = TextDocument.create('test://test/test.html', 'html', 0, value);
const range = Range.create(document.positionAt(rangeStartOffset), document.positionAt(rangeEndOffset));
if (!formatOptions) {
formatOptions = FormattingOptions.create(2, true);
}
let result = await format(languageModes, document, range, formatOptions, undefined, { css: true, javascript: true });
const result = await format(languageModes, document, range, formatOptions, undefined, { css: true, javascript: true });
let actual = TextDocument.applyEdits(document, result);
const actual = TextDocument.applyEdits(document, result);
assert.strictEqual(actual, expected, message);
}
async function assertFormatWithFixture(fixtureName: string, expectedPath: string, options?: any, formatOptions?: FormattingOptions): Promise<void> {
let input = fs.readFileSync(path.join(__dirname, '..', '..', 'src', 'test', 'fixtures', 'inputs', fixtureName)).toString().replace(/\r\n/mg, '\n');
let expected = fs.readFileSync(path.join(__dirname, '..', '..', 'src', 'test', 'fixtures', 'expected', expectedPath)).toString().replace(/\r\n/mg, '\n');
const input = fs.readFileSync(path.join(__dirname, '..', '..', 'src', 'test', 'fixtures', 'inputs', fixtureName)).toString().replace(/\r\n/mg, '\n');
const expected = fs.readFileSync(path.join(__dirname, '..', '..', 'src', 'test', 'fixtures', 'expected', expectedPath)).toString().replace(/\r\n/mg, '\n');
await assertFormat(input, expected, options, formatOptions, expectedPath);
}
@@ -85,7 +85,7 @@ suite('HTML Embedded Formatting', () => {
});
test('EndWithNewline', async () => {
let options = {
const options = {
html: {
format: {
endWithNewline: true
@@ -160,7 +160,7 @@ suite('HTML Embedded Formatting', () => {
);
});
test('#58435', async () => {
let options = {
const options = {
html: {
format: {
contentUnformatted: 'textarea'

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

@@ -15,7 +15,7 @@ async function assertRanges(content: string, expected: (number | string)[][]): P
const offset = content.indexOf('|');
content = content.substr(0, offset) + content.substr(offset + 1);
let workspace = {
const workspace = {
settings: {},
folders: [{ name: 'foo', uri: 'test://foo' }]
};

2
extensions/html-language-features/server/src/test/semanticTokens.test.ts
View File

@@ -28,7 +28,7 @@ async function assertTokens(lines: string[], expected: ExpectedToken[], ranges?:
const legend = semanticTokensProvider.legend;
const actual = await semanticTokensProvider.getSemanticTokens(document, ranges);
let actualRanges = [];
const actualRanges = [];
let lastLine = 0;
let lastCharacter = 0;
for (let i = 0; i < actual.length; i += 5) {

6
extensions/html-language-features/server/src/utils/arrays.ts
View File

@@ -40,7 +40,7 @@ function _divideAndMerge<T>(data: T[], compare: (a: T, b: T) => number): void {
let rightIdx = 0;
let i = 0;
while (leftIdx < left.length && rightIdx < right.length) {
let ret = compare(left[leftIdx], right[rightIdx]);
const ret = compare(left[leftIdx], right[rightIdx]);
if (ret <= 0) {
// smaller_equal -> take left to preserve order
data[i++] = left[leftIdx++];
@@ -62,8 +62,8 @@ export function binarySearch<T>(array: T[], key: T, comparator: (op1: T, op2: T)
high = array.length - 1;
while (low <= high) {
let mid = ((low + high) / 2) | 0;
let comp = comparator(array[mid], key);
const mid = ((low + high) / 2) | 0;
const comp = comparator(array[mid], key);
if (comp < 0) {
low = mid + 1;
} else if (comp > 0) {

4
extensions/html-language-features/server/src/utils/documentContext.ts
View File

@@ -10,7 +10,7 @@ import { resolvePath } from '../requests';
export function getDocumentContext(documentUri: string, workspaceFolders: WorkspaceFolder[]): DocumentContext {
function getRootFolder(): string | undefined {
for (let folder of workspaceFolders) {
for (const folder of workspaceFolders) {
let folderURI = folder.uri;
if (!endsWith(folderURI, '/')) {
folderURI = folderURI + '/';
@@ -25,7 +25,7 @@ export function getDocumentContext(documentUri: string, workspaceFolders: Worksp
return {
resolveReference: (ref: string, base = documentUri) => {
if (ref[0] === '/') { // resolve absolute path against the current workspace folder
let folderUri = getRootFolder();
const folderUri = getRootFolder();
if (folderUri) {
return folderUri + ref.substr(1);
}

2
extensions/html-language-features/server/src/utils/runner.ts
View File

@@ -8,7 +8,7 @@ import { RuntimeEnvironment } from '../htmlServer';
export function formatError(message: string, err: any): string {
if (err instanceof Error) {
let error = <Error>err;
const error = <Error>err;
return `${message}: ${error.message}\n${error.stack}`;
} else if (typeof err === 'string') {
return `${message}: ${err}`;

8
extensions/html-language-features/server/src/utils/strings.ts
View File

@@ -8,11 +8,11 @@ export function getWordAtText(text: string, offset: number, wordDefinition: RegE
while (lineStart > 0 && !isNewlineCharacter(text.charCodeAt(lineStart - 1))) {
lineStart--;
}
let offsetInLine = offset - lineStart;
let lineText = text.substr(lineStart);
const offsetInLine = offset - lineStart;
const lineText = text.substr(lineStart);
// make a copy of the regex as to not keep the state
let flags = wordDefinition.ignoreCase ? 'gi' : 'g';
const flags = wordDefinition.ignoreCase ? 'gi' : 'g';
wordDefinition = new RegExp(wordDefinition.source, flags);
let match = wordDefinition.exec(lineText);
@@ -41,7 +41,7 @@ export function startsWith(haystack: string, needle: string): boolean {
}
export function endsWith(haystack: string, needle: string): boolean {
let diff = haystack.length - needle.length;
const diff = haystack.length - needle.length;
if (diff > 0) {
return haystack.indexOf(needle, diff) === diff;
} else if (diff === 0) {