936 lines
41 KiB
TypeScript
936 lines
41 KiB
TypeScript
/// SPDX-License-Identifier: GPL-3.0-or-later
|
|
/// SPDX-FileCopyrightText: Copyright © 2016-2023 Tony Garnock-Jones <tonyg@leastfixedpoint.com>
|
|
|
|
import { compile, Syntax } from '@syndicate-lang/compiler';
|
|
import tslib from 'typescript/lib/tsserverlibrary';
|
|
import crypto from 'crypto';
|
|
import path from 'path';
|
|
|
|
const boot: tslib.server.PluginModuleFactory = ({ typescript: ts }) => {
|
|
|
|
interface SyndicateInfo {
|
|
sourceFile: ts.SourceFile;
|
|
originalSource: string;
|
|
diagnostics: ts.DiagnosticWithLocation[];
|
|
targetToSourceMap: Syntax.SpanIndex<Syntax.Token>;
|
|
sourceToTargetMap: Syntax.SpanIndex<number>;
|
|
}
|
|
|
|
const syndicateInfo: Map<string, SyndicateInfo> = new Map();
|
|
|
|
const syndicateRootDirs: Set<string> = new Set();
|
|
|
|
function shouldExpand(fileName: string): boolean {
|
|
let result = false;
|
|
syndicateRootDirs.forEach(d => {
|
|
if (fileName.startsWith(d)) {
|
|
result = true;
|
|
}
|
|
});
|
|
return result;
|
|
}
|
|
|
|
function getInfo(fileName: string): SyndicateInfo | undefined {
|
|
return syndicateInfo.get(fileName);
|
|
}
|
|
|
|
function fixupDocumentSpan(loc: ts.DocumentSpan | undefined): ts.DocumentSpan | undefined {
|
|
if (loc !== void 0) {
|
|
withFileName(loc.fileName, () => void 0, (fixupLoc) => {
|
|
fixupLoc.span(loc.textSpan);
|
|
fixupLoc.span(loc.contextSpan);
|
|
});
|
|
withFileName(loc.originalFileName, () => void 0, (fixupOriginal) => {
|
|
fixupOriginal.span(loc.originalTextSpan);
|
|
fixupOriginal.span(loc.originalContextSpan);
|
|
});
|
|
}
|
|
return loc;
|
|
}
|
|
|
|
class Fixup {
|
|
readonly info: SyndicateInfo;
|
|
|
|
constructor(info: SyndicateInfo) {
|
|
this.info = info;
|
|
}
|
|
|
|
loc(start: number): number | undefined {
|
|
const p = this.info.targetToSourceMap.get(start);
|
|
if (p === null) return undefined;
|
|
return p.firstItem.start.pos + p.offset;
|
|
}
|
|
|
|
span(s: ts.TextSpan): ts.TextSpan;
|
|
span(s: undefined): undefined;
|
|
span(s: ts.TextSpan | undefined): ts.TextSpan | undefined;
|
|
span(s: ts.TextSpan | undefined): ts.TextSpan | undefined {
|
|
if (s !== void 0 && !('__syndicate_translated__' in s)) {
|
|
const newStart = this.loc(s.start);
|
|
if (newStart === void 0) throw new Error(
|
|
"Source position unavailable for TextSpan " + JSON.stringify(s));
|
|
s.start = newStart;
|
|
(s as any).__syndicate_translated__ = true;
|
|
}
|
|
return s;
|
|
}
|
|
|
|
diagnostic<T extends ts.Diagnostic>(d: T, ds: T[]) {
|
|
if (d.start !== void 0 && !('__syndicate_translated__' in d)) {
|
|
const p = this.info.targetToSourceMap.get(d.start);
|
|
if (p === null) return;
|
|
if (p.firstItem.synthetic) return;
|
|
d.start = p.firstItem.start.pos + p.offset;
|
|
(d as any).__syndicate_translated__ = true;
|
|
}
|
|
ds.push(d);
|
|
}
|
|
|
|
diagnostics<T extends ts.Diagnostic>(ds: T[]): T[] {
|
|
const vs: T[] = [];
|
|
ds.forEach(d => this.diagnostic(d, vs));
|
|
return vs;
|
|
}
|
|
}
|
|
|
|
class PositionFixup extends Fixup {
|
|
readonly target: Syntax.SpanResult<number>;
|
|
|
|
constructor(info: SyndicateInfo, target: Syntax.SpanResult<number>) {
|
|
super(info);
|
|
this.target = target;
|
|
}
|
|
|
|
get targetStart(): number {
|
|
return this.target.firstItem + this.target.offset;
|
|
}
|
|
|
|
get targetEnd(): number {
|
|
return this.target.lastItem + this.target.offset;
|
|
}
|
|
}
|
|
|
|
function withFileName<T>(fileName: string | undefined,
|
|
kNoInfo: () => T,
|
|
k: (f: Fixup) => T): T
|
|
{
|
|
if (fileName === void 0) return kNoInfo();
|
|
const info = getInfo(fileName);
|
|
if (info === void 0) return kNoInfo();
|
|
return k(new Fixup(info));
|
|
}
|
|
|
|
function withPositions<T>(fileName: string,
|
|
positions: Array<number>,
|
|
kNoInfo: () => T,
|
|
kNoPosition: () => T,
|
|
k: (f: Array<PositionFixup>) => T): T
|
|
{
|
|
return withFileName(fileName, kNoInfo, (fx) => {
|
|
const t = positions.map(p => fx.info.sourceToTargetMap.get(p));
|
|
if (t.some(p => p === null)) return kNoPosition();
|
|
return k(t.map(p => new PositionFixup(fx.info, p!)));
|
|
});
|
|
}
|
|
|
|
function withPosition<T>(fileName: string,
|
|
position: number,
|
|
kNoInfo: () => T,
|
|
kNoPosition: () => T,
|
|
k: (f: PositionFixup) => T): T
|
|
{
|
|
return withPositions(fileName, [position], kNoInfo, kNoPosition, ([f]) => k(f));
|
|
}
|
|
|
|
function compileWithDiagnostics(
|
|
name: string,
|
|
source: string,
|
|
makeSourceFile: (expandedText: string) => ts.SourceFile,
|
|
): {
|
|
expandedText: string,
|
|
targetToSourceMap: Syntax.SpanIndex<Syntax.Token>,
|
|
sourceToTargetMap: Syntax.SpanIndex<number>,
|
|
sourceFile: ts.SourceFile,
|
|
diagnostics: ts.DiagnosticWithLocation[],
|
|
} {
|
|
const diagnostics: Array<{ message: string, start?: Syntax.Pos, end?: Syntax.Pos }> = [];
|
|
// console.log(`Syndicate expanding ${name}: ${JSON.stringify(source)}`);
|
|
console.log(`Syndicate expanding ${name}`);
|
|
const startTime = +new Date();
|
|
const { text: expandedText, targetToSourceMap, sourceToTargetMap } = compile({
|
|
source,
|
|
name,
|
|
typescript: true,
|
|
emitError: (message, start, end) => {
|
|
console.error(`${Syntax.formatPos(start)}-${Syntax.formatPos(end)}: ${message}`);
|
|
diagnostics.push({ message, start, end });
|
|
},
|
|
});
|
|
const stopTime = +new Date();
|
|
console.log(`Syndicate expansion of ${name} took ${stopTime - startTime} ms`);
|
|
const sourceFile = makeSourceFile(expandedText);
|
|
return {
|
|
expandedText,
|
|
targetToSourceMap,
|
|
sourceToTargetMap,
|
|
sourceFile,
|
|
diagnostics: diagnostics.map(({ message, start, end }) => ({
|
|
category: ts.DiagnosticCategory.Error,
|
|
code: 99999,
|
|
file: sourceFile,
|
|
start: start?.pos ?? 0,
|
|
length: Math.max(0, (end?.pos ?? 0) - (start?.pos ?? 0)),
|
|
messageText: message,
|
|
})),
|
|
};
|
|
}
|
|
|
|
function expandFile(
|
|
fileName: string,
|
|
inputText: string,
|
|
makeSourceFile: (expandedText: string) => ts.SourceFile,
|
|
): ts.SourceFile {
|
|
const { expandedText, sourceFile, targetToSourceMap, sourceToTargetMap, diagnostics } =
|
|
compileWithDiagnostics(fileName, inputText, makeSourceFile);
|
|
const info = {
|
|
sourceFile,
|
|
originalSource: inputText,
|
|
diagnostics,
|
|
targetToSourceMap,
|
|
sourceToTargetMap,
|
|
};
|
|
syndicateInfo.set(fileName, info);
|
|
(sourceFile as any).version =
|
|
crypto.createHash('sha256').update(expandedText).digest('hex');
|
|
return sourceFile;
|
|
}
|
|
|
|
{
|
|
const oldCreateSourceFile = ts.createSourceFile;
|
|
|
|
function createSourceFile(
|
|
fileName: string,
|
|
sourceText: string,
|
|
languageVersionOrOptions: ts.ScriptTarget | ts.CreateSourceFileOptions,
|
|
setParentNodes?: boolean,
|
|
scriptKind?: ts.ScriptKind,
|
|
): ts.SourceFile {
|
|
const delegate = (text: string) => oldCreateSourceFile(
|
|
fileName,
|
|
text,
|
|
languageVersionOrOptions,
|
|
setParentNodes,
|
|
scriptKind);
|
|
if (shouldExpand(fileName)) {
|
|
// console.log('createSourceFile', fileName, sourceText);
|
|
return expandFile(fileName, sourceText, delegate);
|
|
} else {
|
|
return delegate(sourceText);
|
|
}
|
|
}
|
|
|
|
ts.createSourceFile = createSourceFile;
|
|
}
|
|
|
|
{
|
|
const oldUpdateSourceFile = ts.updateSourceFile;
|
|
|
|
function commonPrefixLength(a: string, b: string): number {
|
|
const limit = Math.min(a.length, b.length);
|
|
for (let i = 0; i < limit; i++) {
|
|
if (a[i] !== b[i]) return i;
|
|
}
|
|
return limit;
|
|
}
|
|
|
|
function commonSuffixLength(a: string, b: string): number {
|
|
const limit = Math.min(a.length, b.length);
|
|
for (let i = 0; i < limit; i++) {
|
|
if (a[a.length - i - 1] !== b[b.length - i - 1]) return i;
|
|
}
|
|
return limit;
|
|
}
|
|
|
|
function updateSourceFile(
|
|
sourceFile: ts.SourceFile,
|
|
newText: string,
|
|
textChangeRange: ts.TextChangeRange,
|
|
aggressiveChecks?: boolean,
|
|
): ts.SourceFile {
|
|
return withFileName(
|
|
sourceFile.fileName,
|
|
() => oldUpdateSourceFile(sourceFile, newText, textChangeRange, aggressiveChecks),
|
|
(fx) => {
|
|
const oldInfo = fx.info;
|
|
return expandFile(
|
|
sourceFile.fileName,
|
|
oldInfo.originalSource,
|
|
(newExpandedText) => {
|
|
const oldExpandedText = oldInfo.sourceFile.text;
|
|
if (oldExpandedText === newExpandedText) {
|
|
// console.log('updateSourceFile', 'no change');
|
|
return oldInfo.sourceFile;
|
|
} else {
|
|
const prefix = commonPrefixLength(oldExpandedText, newExpandedText);
|
|
const suffix =
|
|
commonSuffixLength(oldExpandedText.substring(prefix),
|
|
newExpandedText.substring(prefix));
|
|
const newChangeRange = {
|
|
span: {
|
|
start: prefix,
|
|
length: oldExpandedText.length - prefix - suffix,
|
|
},
|
|
newLength: newExpandedText.length - prefix - suffix,
|
|
} satisfies ts.TextChangeRange;
|
|
// console.log('updateSourceFile', JSON.stringify({
|
|
// oldSyndicateText: oldInfo.originalSource,
|
|
// newSyndicateText: newText,
|
|
// oldExpandedText,
|
|
// newExpandedText,
|
|
// oldLength: oldExpandedText.length,
|
|
// newLength: newExpandedText.length,
|
|
// oldChangeRange: textChangeRange,
|
|
// newChangeRange,
|
|
// prefix,
|
|
// suffix,
|
|
// }, void 0, 2));
|
|
return oldUpdateSourceFile(
|
|
sourceFile, newExpandedText, newChangeRange, aggressiveChecks);
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
ts.updateSourceFile = updateSourceFile;
|
|
}
|
|
|
|
{
|
|
const oldEditContent = ts.server.ScriptInfo.prototype.editContent;
|
|
ts.server.ScriptInfo.prototype.editContent =
|
|
function (start: number, end: number, newText: string): void {
|
|
// console.log('SyndicateScriptInfo.editContent', JSON.stringify({
|
|
// fileName: this.fileName,
|
|
// start,
|
|
// end,
|
|
// newText,
|
|
// oldText: (this as any).textStorage.text ?? ["MISSING"],
|
|
// }, void 0, 2));
|
|
withFileName(this.fileName,
|
|
() => oldEditContent.call(this, start, end, newText),
|
|
(fx) => {
|
|
const info = fx.info;
|
|
const revised = info.originalSource.substring(0, start) +
|
|
newText +
|
|
info.originalSource.substring(end);
|
|
info.originalSource = revised;
|
|
oldEditContent.call(this, start, end, newText);
|
|
});
|
|
};
|
|
}
|
|
|
|
// class SyndicateScriptInfo extends ts.server.ScriptInfo {
|
|
// constructor(
|
|
// host: ts.server.ServerHost,
|
|
// fileName: ts.server.NormalizedPath,
|
|
// scriptKind: ts.ScriptKind,
|
|
// hasMixedContent: boolean,
|
|
// path: ts.Path,
|
|
// initialVersion?: ts.server.ScriptInfoVersion,
|
|
// ) {
|
|
// if (shouldExpand(fileName)) {
|
|
// console.log('SyndicateScriptInfo constructor', fileName);
|
|
// }
|
|
// super(host, fileName, scriptKind, hasMixedContent, path, initialVersion);
|
|
// }
|
|
//
|
|
// editContent(start: number, end: number, newText: string): void {
|
|
// // console.log('SyndicateScriptInfo.editContent', this.fileName, start, end, newText);
|
|
// withFileName(this.fileName,
|
|
// () => super.editContent(start, end, newText),
|
|
// (fx) => {
|
|
// const info = fx.info;
|
|
// const revised = info.originalSource.substring(0, start) +
|
|
// newText +
|
|
// info.originalSource.substring(end);
|
|
// info.originalSource = revised;
|
|
// this.open(revised);
|
|
// });
|
|
// }
|
|
// }
|
|
//
|
|
// ts.server.ScriptInfo = SyndicateScriptInfo;
|
|
|
|
class SyndicateLanguageService implements ts.LanguageService {
|
|
readonly inner: ts.LanguageService;
|
|
|
|
constructor(inner: ts.LanguageService) {
|
|
this.inner = inner;
|
|
}
|
|
|
|
provideInlayHints(fileName: string, span: ts.TextSpan, preferences: ts.UserPreferences | undefined): ts.InlayHint[] {
|
|
throw new Error('Method not implemented.');
|
|
}
|
|
|
|
getFileReferences(fileName: string): tslib.ReferenceEntry[] {
|
|
throw new Error('Method not implemented.');
|
|
}
|
|
|
|
cleanupSemanticCache(): void {
|
|
}
|
|
|
|
getSyntacticDiagnostics(fileName: string): ts.DiagnosticWithLocation[] {
|
|
const ds = this.inner.getSyntacticDiagnostics(fileName);
|
|
return withFileName(fileName, () => ds, (fixup) => {
|
|
const fixedUp = fixup.diagnostics(ds);
|
|
fixedUp.push(... fixup.info.diagnostics);
|
|
return fixedUp;
|
|
});
|
|
}
|
|
|
|
getSemanticDiagnostics(fileName: string): ts.Diagnostic[] {
|
|
const ds = this.inner.getSemanticDiagnostics(fileName);
|
|
return withFileName(fileName, () => ds, (fixup) => fixup.diagnostics(ds));
|
|
}
|
|
|
|
getSuggestionDiagnostics(fileName: string): ts.DiagnosticWithLocation[] {
|
|
const ds = this.inner.getSuggestionDiagnostics(fileName);
|
|
return withFileName(fileName, () => ds, (fixup) => fixup.diagnostics(ds));
|
|
}
|
|
|
|
getCompilerOptionsDiagnostics(): ts.Diagnostic[] {
|
|
return this.inner.getCompilerOptionsDiagnostics();
|
|
}
|
|
|
|
getSyntacticClassifications(fileName: string, span: ts.TextSpan): ts.ClassifiedSpan[];
|
|
getSyntacticClassifications(fileName: string, span: ts.TextSpan, format: ts.SemanticClassificationFormat): ts.ClassifiedSpan[] | ts.ClassifiedSpan2020[];
|
|
getSyntacticClassifications(fileName: string, span: ts.TextSpan, format?: ts.SemanticClassificationFormat): ts.ClassifiedSpan[] | ts.ClassifiedSpan2020[] {
|
|
return withPosition(
|
|
fileName, span.start,
|
|
() => this.inner.getSyntacticClassifications(fileName, span, format!),
|
|
() => [],
|
|
(fixup) => {
|
|
const cs = this.inner.getSyntacticClassifications(fileName, span, format!);
|
|
cs.forEach((c: ts.ClassifiedSpan | ts.ClassifiedSpan2020) => fixup.span(c.textSpan));
|
|
return cs;
|
|
});
|
|
}
|
|
|
|
getSemanticClassifications(fileName: string, span: ts.TextSpan): ts.ClassifiedSpan[];
|
|
getSemanticClassifications(fileName: string, span: ts.TextSpan, format: ts.SemanticClassificationFormat): ts.ClassifiedSpan[] | ts.ClassifiedSpan2020[];
|
|
getSemanticClassifications(fileName: any, span: ts.TextSpan, format?: ts.SemanticClassificationFormat): ts.ClassifiedSpan[] | ts.ClassifiedSpan2020[] {
|
|
return withPosition(
|
|
fileName, span.start,
|
|
() => this.inner.getSemanticClassifications(fileName, span, format!),
|
|
() => [],
|
|
(fixup) => {
|
|
const cs = this.inner.getSemanticClassifications(fileName, span, format!);
|
|
cs.forEach((c: ts.ClassifiedSpan | ts.ClassifiedSpan2020) => fixup.span(c.textSpan));
|
|
return cs;
|
|
});
|
|
}
|
|
|
|
getEncodedSyntacticClassifications(fileName: string, span: ts.TextSpan): ts.Classifications {
|
|
return withPosition(
|
|
fileName, span.start,
|
|
() => this.inner.getEncodedSyntacticClassifications(fileName, span),
|
|
() => ({ spans: [], endOfLineState: ts.EndOfLineState.None }),
|
|
(fixup) => {
|
|
const cs = this.inner.getEncodedSyntacticClassifications(fileName, span);
|
|
for (let i = 0; i < cs.spans.length; i += 3) {
|
|
const newStart = fixup.loc(cs.spans[i]);
|
|
if (newStart === void 0) {
|
|
cs.spans.splice(i, 3);
|
|
} else {
|
|
cs.spans[i] = newStart;
|
|
}
|
|
}
|
|
return cs;
|
|
});
|
|
}
|
|
|
|
getEncodedSemanticClassifications(fileName: string, span: ts.TextSpan, format?: ts.SemanticClassificationFormat): ts.Classifications {
|
|
return withPosition(
|
|
fileName, span.start,
|
|
() => this.inner.getEncodedSemanticClassifications(fileName, span, format),
|
|
() => ({ spans: [], endOfLineState: ts.EndOfLineState.None }),
|
|
(fixup) => {
|
|
const cs = this.inner.getEncodedSemanticClassifications(fileName, span, format);
|
|
for (let i = 0; i < cs.spans.length; i += 3) {
|
|
const newStart = fixup.loc(cs.spans[i]);
|
|
if (newStart === void 0) {
|
|
cs.spans.splice(i, 3);
|
|
} else {
|
|
cs.spans[i] = newStart;
|
|
}
|
|
}
|
|
return cs;
|
|
});
|
|
}
|
|
|
|
getCompletionsAtPosition(fileName: string, position: number, options: ts.GetCompletionsAtPositionOptions | undefined): ts.WithMetadata<ts.CompletionInfo> | undefined {
|
|
return withPosition(
|
|
fileName, position,
|
|
() => this.inner.getCompletionsAtPosition(fileName, position, options),
|
|
() => void 0,
|
|
(fixup) => {
|
|
const cs = this.inner.getCompletionsAtPosition(fileName, fixup.targetStart, options);
|
|
if (cs !== void 0) {
|
|
fixup.span(cs.optionalReplacementSpan);
|
|
cs.entries.forEach(c => fixup.span(c.replacementSpan));
|
|
}
|
|
return cs;
|
|
});
|
|
}
|
|
|
|
getCompletionEntryDetails(fileName: string,
|
|
position: number,
|
|
entryName: string,
|
|
formatOptions: ts.FormatCodeOptions | ts.FormatCodeSettings | undefined,
|
|
source: string | undefined,
|
|
preferences: ts.UserPreferences | undefined,
|
|
data: ts.CompletionEntryData | undefined): ts.CompletionEntryDetails | undefined {
|
|
return withPosition(
|
|
fileName, position,
|
|
() => this.inner.getCompletionEntryDetails(fileName, position, entryName, formatOptions, source, preferences, data),
|
|
() => void 0,
|
|
(fixup) => {
|
|
const d = this.inner.getCompletionEntryDetails(fileName, fixup.targetStart, entryName, formatOptions, source, preferences, data);
|
|
if (d !== void 0) {
|
|
d.codeActions?.forEach(a =>
|
|
a.changes.forEach(c =>
|
|
c.textChanges.forEach(c =>
|
|
fixup.span(c.span))));
|
|
}
|
|
return d;
|
|
});
|
|
}
|
|
|
|
getCompletionEntrySymbol(fileName: string, position: number, name: string, source: string | undefined): ts.Symbol | undefined {
|
|
// TODO: hmm. Is this acceptable?
|
|
return void 0;
|
|
}
|
|
|
|
getQuickInfoAtPosition(fileName: string, position: number): ts.QuickInfo | undefined {
|
|
return withPosition(
|
|
fileName, position,
|
|
() => this.inner.getQuickInfoAtPosition(fileName, position),
|
|
() => void 0,
|
|
(fixup) => {
|
|
const qi = this.inner.getQuickInfoAtPosition(fileName, fixup.targetStart);
|
|
if (qi !== void 0) fixup.span(qi.textSpan);
|
|
return qi;
|
|
});
|
|
}
|
|
|
|
getNameOrDottedNameSpan(fileName: string, startPos: number, endPos: number): ts.TextSpan | undefined {
|
|
throw new Error('Method not implemented.');
|
|
}
|
|
|
|
getBreakpointStatementAtPosition(fileName: string, position: number): ts.TextSpan | undefined {
|
|
throw new Error('Method not implemented.');
|
|
}
|
|
|
|
getSignatureHelpItems(fileName: string, position: number, options: ts.SignatureHelpItemsOptions | undefined): ts.SignatureHelpItems | undefined {
|
|
return withPosition(
|
|
fileName, position,
|
|
() => this.inner.getSignatureHelpItems(fileName, position, options),
|
|
() => void 0,
|
|
(fixup) => {
|
|
const items = this.inner.getSignatureHelpItems(fileName, fixup.targetStart, options);
|
|
if (items !== void 0) fixup.span(items.applicableSpan);
|
|
return items;
|
|
});
|
|
}
|
|
|
|
getRenameInfo(fileName: string, position: number, options?: ts.RenameInfoOptions): ts.RenameInfo {
|
|
return withPosition(
|
|
fileName, position,
|
|
() => this.inner.getRenameInfo(fileName, position, options),
|
|
() => ({ canRename: false, localizedErrorMessage: 'Identifier not present in expanded source code' }),
|
|
(fixup) => {
|
|
const ri = this.inner.getRenameInfo(fileName, fixup.targetStart, options);
|
|
if (ri.canRename) {
|
|
fixup.span(ri.triggerSpan);
|
|
}
|
|
return ri;
|
|
});
|
|
}
|
|
|
|
findRenameLocations(fileName: string, position: number, findInStrings: boolean, findInComments: boolean, providePrefixAndSuffixTextForRename?: boolean): readonly ts.RenameLocation[] | undefined {
|
|
return withPosition(
|
|
fileName, position,
|
|
() => this.inner.findRenameLocations(fileName, position, findInStrings, findInComments, providePrefixAndSuffixTextForRename),
|
|
() => void 0,
|
|
(fixup) => {
|
|
const locs = this.inner.findRenameLocations(fileName, fixup.targetStart, findInStrings, findInComments, providePrefixAndSuffixTextForRename);
|
|
if (locs !== void 0) locs.forEach(fixupDocumentSpan);
|
|
return locs;
|
|
});
|
|
}
|
|
|
|
getSmartSelectionRange(fileName: string, position: number): ts.SelectionRange {
|
|
throw new Error('Method not implemented.');
|
|
}
|
|
|
|
getDefinitionAtPosition(fileName: string, position: number): readonly ts.DefinitionInfo[] | undefined {
|
|
return withPosition(
|
|
fileName, position,
|
|
() => this.inner.getDefinitionAtPosition(fileName, position),
|
|
() => undefined,
|
|
(fixup) => {
|
|
const dis = this.inner.getDefinitionAtPosition(fileName, fixup.targetStart);
|
|
if (dis !== void 0) dis.forEach(fixupDocumentSpan);
|
|
return dis;
|
|
});
|
|
}
|
|
|
|
getDefinitionAndBoundSpan(fileName: string, position: number): ts.DefinitionInfoAndBoundSpan | undefined {
|
|
return withPosition(
|
|
fileName, position,
|
|
() => this.inner.getDefinitionAndBoundSpan(fileName, position),
|
|
() => undefined,
|
|
(fixup) => {
|
|
const d = this.inner.getDefinitionAndBoundSpan(fileName, fixup.targetStart);
|
|
if (d !== void 0) {
|
|
d.definitions?.forEach(fixupDocumentSpan);
|
|
fixup.span(d.textSpan);
|
|
}
|
|
return d;
|
|
});
|
|
}
|
|
|
|
getTypeDefinitionAtPosition(fileName: string, position: number): readonly ts.DefinitionInfo[] | undefined {
|
|
throw new Error('Method not implemented.');
|
|
}
|
|
|
|
getImplementationAtPosition(fileName: string, position: number): readonly ts.ImplementationLocation[] | undefined {
|
|
throw new Error('Method not implemented.');
|
|
}
|
|
|
|
getReferencesAtPosition(fileName: string, position: number): ts.ReferenceEntry[] | undefined {
|
|
throw new Error('Method not implemented.');
|
|
}
|
|
|
|
findReferences(fileName: string, position: number): ts.ReferencedSymbol[] | undefined {
|
|
throw new Error('Method not implemented.');
|
|
}
|
|
|
|
getDocumentHighlights(fileName: string, position: number, filesToSearch: string[]): ts.DocumentHighlights[] | undefined {
|
|
return withPosition(
|
|
fileName, position,
|
|
() => this.inner.getDocumentHighlights(fileName, position, filesToSearch),
|
|
() => [],
|
|
fixup => {
|
|
const dhs = this.inner.getDocumentHighlights(fileName, fixup.targetStart, filesToSearch);
|
|
if (dhs === void 0) return dhs;
|
|
dhs.forEach(dh => dh.highlightSpans.forEach((s: tslib.HighlightSpan) => {
|
|
fixup.span(s.textSpan);
|
|
fixup.span(s.contextSpan);
|
|
}));
|
|
return dhs;
|
|
});
|
|
}
|
|
|
|
getOccurrencesAtPosition(fileName: string, position: number): readonly ts.ReferenceEntry[] | undefined {
|
|
throw new Error('Method not implemented.');
|
|
}
|
|
|
|
getNavigateToItems(searchValue: string, maxResultCount?: number, fileName?: string, excludeDtsFiles?: boolean): ts.NavigateToItem[] {
|
|
throw new Error('Method not implemented.');
|
|
}
|
|
|
|
getNavigationBarItems(fileName: string): ts.NavigationBarItem[] {
|
|
throw new Error('Method not implemented.');
|
|
}
|
|
|
|
getNavigationTree(fileName: string): ts.NavigationTree {
|
|
const t = this.inner.getNavigationTree(fileName);
|
|
return withFileName(fileName, () => t, (fixup) => {
|
|
function fixupNavigationTree(t: ts.NavigationTree) {
|
|
fixup.span(t.nameSpan);
|
|
t.spans.forEach(s => fixup.span(s));
|
|
t.childItems?.forEach(fixupNavigationTree);
|
|
}
|
|
fixupNavigationTree(t);
|
|
return t;
|
|
});
|
|
}
|
|
|
|
prepareCallHierarchy(fileName: string, position: number): ts.CallHierarchyItem | ts.CallHierarchyItem[] | undefined {
|
|
throw new Error('Method not implemented.');
|
|
}
|
|
|
|
provideCallHierarchyIncomingCalls(fileName: string, position: number): ts.CallHierarchyIncomingCall[] {
|
|
throw new Error('Method not implemented.');
|
|
}
|
|
|
|
provideCallHierarchyOutgoingCalls(fileName: string, position: number): ts.CallHierarchyOutgoingCall[] {
|
|
throw new Error('Method not implemented.');
|
|
}
|
|
|
|
getOutliningSpans(fileName: string): ts.OutliningSpan[] {
|
|
throw new Error('Method not implemented.');
|
|
}
|
|
|
|
getTodoComments(fileName: string, descriptors: ts.TodoCommentDescriptor[]): ts.TodoComment[] {
|
|
throw new Error('Method not implemented.');
|
|
}
|
|
|
|
getBraceMatchingAtPosition(fileName: string, position: number): ts.TextSpan[] {
|
|
throw new Error('Method not implemented.');
|
|
}
|
|
|
|
getIndentationAtPosition(fileName: string, position: number, options: ts.EditorOptions | ts.EditorSettings): number {
|
|
throw new Error('Method not implemented.');
|
|
}
|
|
|
|
getFormattingEditsForRange(fileName: string, start: number, end: number, options: ts.FormatCodeOptions | ts.FormatCodeSettings): ts.TextChange[] {
|
|
return withPositions(
|
|
fileName, [start, end],
|
|
() => this.inner.getFormattingEditsForRange(fileName, start, end, options),
|
|
() => [],
|
|
([fixStart, fixEnd]) => {
|
|
const edits = this.inner.getFormattingEditsForRange(fileName, fixStart.targetStart, fixEnd.targetEnd, options);
|
|
edits.forEach(e => fixStart.span(e.span));
|
|
return edits;
|
|
});
|
|
}
|
|
|
|
getFormattingEditsForDocument(fileName: string, options: ts.FormatCodeOptions | ts.FormatCodeSettings): ts.TextChange[] {
|
|
const edits = this.inner.getFormattingEditsForDocument(fileName, options);
|
|
withFileName(fileName, () => void 0, (fixup) => edits.forEach(e => fixup.span(e.span)));
|
|
return edits;
|
|
}
|
|
|
|
getFormattingEditsAfterKeystroke(fileName: string, position: number, key: string, options: ts.FormatCodeOptions | ts.FormatCodeSettings): ts.TextChange[] {
|
|
return withPosition(
|
|
fileName, position,
|
|
() => this.inner.getFormattingEditsAfterKeystroke(fileName, position, key, options),
|
|
() => [],
|
|
(fixup) => {
|
|
const edits = this.inner.getFormattingEditsAfterKeystroke(fileName, fixup.targetStart, key, options);
|
|
edits.forEach(e => fixup.span(e.span));
|
|
return edits;
|
|
});
|
|
}
|
|
|
|
getDocCommentTemplateAtPosition(fileName: string, position: number): ts.TextInsertion | undefined {
|
|
throw new Error('Method not implemented.');
|
|
}
|
|
|
|
isValidBraceCompletionAtPosition(fileName: string, position: number, openingBrace: number): boolean {
|
|
throw new Error('Method not implemented.');
|
|
}
|
|
|
|
getJsxClosingTagAtPosition(fileName: string, position: number): ts.JsxClosingTagInfo | undefined {
|
|
throw new Error('Method not implemented.');
|
|
}
|
|
|
|
getSpanOfEnclosingComment(fileName: string, position: number, onlyMultiLine: boolean): ts.TextSpan | undefined {
|
|
throw new Error('Method not implemented.');
|
|
}
|
|
|
|
getCodeFixesAtPosition(fileName: string, start: number, end: number, errorCodes: readonly number[], formatOptions: ts.FormatCodeSettings, preferences: ts.UserPreferences): readonly ts.CodeFixAction[] {
|
|
return withPositions(
|
|
fileName, [start, end],
|
|
() => this.inner.getCodeFixesAtPosition(fileName,
|
|
start,
|
|
end,
|
|
errorCodes,
|
|
formatOptions,
|
|
preferences),
|
|
() => [],
|
|
([fixStart, fixEnd]) => {
|
|
const fixes = this.inner.getCodeFixesAtPosition(fileName,
|
|
fixStart.targetStart,
|
|
fixEnd.targetEnd,
|
|
errorCodes,
|
|
formatOptions,
|
|
preferences);
|
|
fixes.forEach(f =>
|
|
f.changes.forEach(change =>
|
|
change.textChanges.forEach(c =>
|
|
fixStart.span(c.span))));
|
|
return fixes;
|
|
});
|
|
}
|
|
|
|
getCombinedCodeFix(scope: ts.CombinedCodeFixScope, fixId: {}, formatOptions: ts.FormatCodeSettings, preferences: ts.UserPreferences): ts.CombinedCodeActions {
|
|
const actions = this.inner.getCombinedCodeFix(scope, fixId, formatOptions, preferences);
|
|
actions.changes.forEach(change => {
|
|
const info = getInfo(change.fileName);
|
|
if (info !== void 0) {
|
|
const fixup = new Fixup(info);
|
|
change.textChanges.forEach(c => fixup.span(c.span));
|
|
}
|
|
});
|
|
return actions;
|
|
}
|
|
|
|
applyCodeActionCommand(action: ts.InstallPackageAction, formatSettings?: ts.FormatCodeSettings): Promise<ts.ApplyCodeActionCommandResult>;
|
|
applyCodeActionCommand(action: ts.InstallPackageAction[], formatSettings?: ts.FormatCodeSettings): Promise<ts.ApplyCodeActionCommandResult[]>;
|
|
applyCodeActionCommand(action: ts.InstallPackageAction | ts.InstallPackageAction[], formatSettings?: ts.FormatCodeSettings): Promise<ts.ApplyCodeActionCommandResult | ts.ApplyCodeActionCommandResult[]>;
|
|
applyCodeActionCommand(fileName: string, action: ts.InstallPackageAction): Promise<ts.ApplyCodeActionCommandResult>;
|
|
applyCodeActionCommand(fileName: string, action: ts.InstallPackageAction[]): Promise<ts.ApplyCodeActionCommandResult[]>;
|
|
applyCodeActionCommand(fileName: string, action: ts.InstallPackageAction | ts.InstallPackageAction[]): Promise<ts.ApplyCodeActionCommandResult | ts.ApplyCodeActionCommandResult[]>;
|
|
applyCodeActionCommand(fileName: any, action?: any): any {
|
|
throw new Error('Method not implemented.');
|
|
}
|
|
|
|
getApplicableRefactors(fileName: string, positionOrRange: number | ts.TextRange, preferences: ts.UserPreferences | undefined, triggerReason?: ts.RefactorTriggerReason): ts.ApplicableRefactorInfo[] {
|
|
return this.inner.getApplicableRefactors(fileName, positionOrRange, preferences, triggerReason);
|
|
}
|
|
|
|
getEditsForRefactor(fileName: string, formatOptions: ts.FormatCodeSettings, positionOrRange: number | ts.TextRange, refactorName: string, actionName: string, preferences: ts.UserPreferences | undefined): ts.RefactorEditInfo | undefined {
|
|
throw new Error('Method not implemented.');
|
|
}
|
|
|
|
organizeImports(scope: ts.CombinedCodeFixScope, formatOptions: ts.FormatCodeSettings, preferences: ts.UserPreferences | undefined): readonly ts.FileTextChanges[] {
|
|
throw new Error('Method not implemented.');
|
|
}
|
|
|
|
getEditsForFileRename(oldFilePath: string, newFilePath: string, formatOptions: ts.FormatCodeSettings, preferences: ts.UserPreferences | undefined): readonly ts.FileTextChanges[] {
|
|
throw new Error('Method not implemented.');
|
|
}
|
|
|
|
getEmitOutput(fileName: string, emitOnlyDtsFiles?: boolean, forceDtsEmit?: boolean): ts.EmitOutput {
|
|
throw new Error('Method not implemented.');
|
|
}
|
|
|
|
getProgram(): ts.Program | undefined {
|
|
return this.inner.getProgram();
|
|
}
|
|
|
|
toggleLineComment(fileName: string, textRange: ts.TextRange): ts.TextChange[] {
|
|
throw new Error('Method not implemented.');
|
|
}
|
|
|
|
toggleMultilineComment(fileName: string, textRange: ts.TextRange): ts.TextChange[] {
|
|
throw new Error('Method not implemented.');
|
|
}
|
|
|
|
commentSelection(fileName: string, textRange: ts.TextRange): ts.TextChange[] {
|
|
throw new Error('Method not implemented.');
|
|
}
|
|
|
|
uncommentSelection(fileName: string, textRange: ts.TextRange): ts.TextChange[] {
|
|
throw new Error('Method not implemented.');
|
|
}
|
|
|
|
dispose(): void {
|
|
throw new Error('Method not implemented.');
|
|
}
|
|
|
|
getNonBoundSourceFile(fileName: string): ts.SourceFile {
|
|
throw new Error('Method not implemented.');
|
|
}
|
|
|
|
getAutoImportProvider(): ts.Program | undefined {
|
|
throw new Error('Method not implemented.');
|
|
}
|
|
|
|
toLineColumnOffset(fileName: string, position: number): ts.LineAndCharacter {
|
|
function search(t: string | undefined, position: number): ts.LineAndCharacter {
|
|
if (t === void 0) return { line: 0, character: 0 };
|
|
const p = Syntax.startPos(fileName);
|
|
for (let i = 0; i < position; i++) Syntax.advancePos(p, t[i]);
|
|
return { line: p.line - 1, character: p.column };
|
|
}
|
|
return withFileName(
|
|
fileName,
|
|
() => (this.inner.toLineColumnOffset?.(fileName, position) ??
|
|
search(this.inner.getProgram()?.getSourceFile(fileName)?.text, position)),
|
|
(fixup) =>
|
|
search(fixup.info.originalSource, position));
|
|
}
|
|
|
|
// getSourceMapper(): ts.SourceMapper {
|
|
// throw new Error('Method not implemented.');
|
|
// }
|
|
|
|
clearSourceMapperCache(): void {
|
|
throw new Error('Method not implemented.');
|
|
}
|
|
}
|
|
|
|
function finalSlash(s: string): string {
|
|
if (s[s.length - 1] !== '/') s = s + '/';
|
|
return s;
|
|
}
|
|
|
|
class SyndicatePlugin implements ts.server.PluginModule {
|
|
create(createInfo: ts.server.PluginCreateInfo): ts.LanguageService {
|
|
const project = createInfo.project;
|
|
|
|
const options = project.getCompilerOptions();
|
|
if (options.rootDir !== void 0) {
|
|
syndicateRootDirs.add(finalSlash(options.rootDir));
|
|
}
|
|
if (options.rootDirs !== void 0) {
|
|
options.rootDirs.forEach(d => syndicateRootDirs.add(finalSlash(d)));
|
|
}
|
|
if (options.rootDir === void 0 && options.rootDirs === void 0) {
|
|
syndicateRootDirs.add(finalSlash(path.resolve('.')));
|
|
}
|
|
|
|
// // This next block is required to flush out previously-created ScriptInfo instances
|
|
// // for our project, since they were created before our plugin was even loaded and
|
|
// // our plugin monkey-patches ScriptInfo to SyndicateScriptInfo.
|
|
// {
|
|
// const infos: Map<string, ts.server.ScriptInfo> =
|
|
// (project.projectService as any).filenameToScriptInfo;
|
|
// const oldInfos = Array.from(infos.values());
|
|
|
|
// infos.clear();
|
|
// for (const info of oldInfos) {
|
|
|
|
// if (!shouldExpand(info.fileName)) {
|
|
// continue;
|
|
// }
|
|
|
|
// const existingText = (info as any).textStorage.text;
|
|
|
|
// console.log('---', JSON.stringify({
|
|
// fileName: info.fileName,
|
|
// existingText,
|
|
// containingProjects: info.containingProjects.map(p => p.getProjectName()),
|
|
// }, void 0, 2));
|
|
|
|
// const newInfo = new SyndicateScriptInfo(
|
|
// (info as any).host,
|
|
// info.fileName,
|
|
// info.scriptKind,
|
|
// info.hasMixedContent,
|
|
// info.path,
|
|
// (info as any).textStorage.version);
|
|
// (newInfo as any).textStorage = (info as any).textStorage;
|
|
// infos.set(info.fileName, newInfo);
|
|
// // ^ transfers necessary live information from old ScriptInfo instances to
|
|
// // new SyndicateScriptInfo instances, so open files with syntax errors keep
|
|
// // their syntax error info.
|
|
|
|
// info.close();
|
|
// // ^ detaches old ScriptInfo from projects, so we don't end up with bizarre
|
|
// // duplicates in e.g. automated renamings.
|
|
|
|
// info.detachAllProjects();
|
|
// // info.detachFromProject(project);
|
|
// newInfo.attachToProject(project);
|
|
|
|
// newInfo.open(existingText);
|
|
// // ^ flag the info as open again, so that a (re)compilation happens and any
|
|
// // existing syntax errors actually show up
|
|
|
|
// // project.getSourceFile(info.fileName as any);
|
|
// }
|
|
// }
|
|
|
|
return new SyndicateLanguageService(createInfo.languageService);
|
|
}
|
|
}
|
|
|
|
return new SyndicatePlugin();
|
|
|
|
};
|
|
export = boot;
|