x.innerHTML).join("\n")}}
+ />
+ )
+ } finally {
+ el.remove()
+ }
+}
+
+async function editorTokenized(editor: Atom.TextEditor) {
+ return new Promise(resolve => {
+ if (editor.getBuffer().getLanguageMode().fullyTokenized) {
+ resolve()
+ } else {
+ const disp = editor.onDidTokenize(() => {
+ disp.dispose()
+ resolve()
+ })
+ }
+ })
+}
diff --git a/lib/main/atom-ide/definitionsProvider.ts b/lib/main/atom-ide/definitionsProvider.ts
new file mode 100644
index 000000000..36740d714
--- /dev/null
+++ b/lib/main/atom-ide/definitionsProvider.ts
@@ -0,0 +1,41 @@
+import {Definition, DefinitionProvider} from "atom/ide"
+import {FileSpan} from "typescript/lib/protocol"
+import {GetClientFunction} from "../../client"
+import {
+ getFilePathPosition,
+ isTypescriptEditorWithPath,
+ spanToRange,
+ typeScriptScopes,
+} from "../atom/utils"
+
+export function getDefinitionProvider(getClient: GetClientFunction): DefinitionProvider {
+ return {
+ priority: 0,
+ grammarScopes: typeScriptScopes(),
+ wordRegExp: /([A-Za-z0-9_])+|['"`](\\.|[^'"`\\\\])*['"`]/g,
+ async getDefinition(editor, position) {
+ if (!isTypescriptEditorWithPath(editor)) return
+ const location = getFilePathPosition(editor, position)
+ if (!location) return
+ const client = await getClient(location.file)
+ const result = await client.execute("definition", location)
+ if (!result.body) return
+ if (result.body.length === 0) return
+
+ return {
+ queryRange: undefined,
+ definitions: result.body.map(fileSpanToDefinition),
+ }
+ },
+ }
+}
+
+function fileSpanToDefinition(span: FileSpan): Definition {
+ const range = spanToRange(span)
+ return {
+ path: span.file,
+ position: range.start,
+ range,
+ language: "TypeScript",
+ }
+}
diff --git a/lib/main/atom-ide/findReferencesProvider.ts b/lib/main/atom-ide/findReferencesProvider.ts
new file mode 100644
index 000000000..64278bb40
--- /dev/null
+++ b/lib/main/atom-ide/findReferencesProvider.ts
@@ -0,0 +1,33 @@
+import {FindReferencesProvider, Reference} from "atom/ide"
+import {GetClientFunction} from "../../client"
+import {getFilePathPosition, isTypescriptEditorWithPath, locationsToRange} from "../atom/utils"
+
+export function getFindReferencesProvider(getClient: GetClientFunction): FindReferencesProvider {
+ return {
+ async isEditorSupported(editor) {
+ return isTypescriptEditorWithPath(editor)
+ },
+ async findReferences(editor, position) {
+ const location = getFilePathPosition(editor, position)
+ if (!location) return
+
+ const client = await getClient(location.file)
+ const result = await client.execute("references", location)
+ if (!result.body) return
+ return {
+ type: "data",
+ baseUri: location.file,
+ referencedSymbolName: result.body.symbolDisplayString,
+ references: result.body.refs.map(refTsToIde),
+ }
+ },
+ }
+}
+
+function refTsToIde(ref: protocol.ReferencesResponseItem): Reference {
+ return {
+ uri: ref.file,
+ range: locationsToRange(ref.start, ref.end),
+ name: undefined,
+ }
+}
diff --git a/lib/main/atom-ide/hyperclickProvider.ts b/lib/main/atom-ide/hyperclickProvider.ts
new file mode 100644
index 000000000..717a71f72
--- /dev/null
+++ b/lib/main/atom-ide/hyperclickProvider.ts
@@ -0,0 +1,36 @@
+import * as Atom from "atom"
+import {HyperclickProvider} from "atom/ide"
+import {GetClientFunction} from "../../client"
+import {handleDefinitionResult} from "../atom/commands/goToDeclaration"
+import {Dependencies} from "../atom/commands/registry"
+import {isTypescriptEditorWithPath} from "../atom/utils"
+
+export function getHyperclickProvider(
+ getClient: GetClientFunction,
+ histGoForward: Dependencies["histGoForward"],
+): HyperclickProvider {
+ return {
+ priority: 0,
+ providerName: "typescript-hyperclick-provider",
+ wordRegExp: /([A-Za-z0-9_])+|['"`](\\.|[^'"`\\\\])*['"`]/g,
+ async getSuggestionForWord(editor: Atom.TextEditor, _text: string, range: Atom.Range) {
+ if (!isTypescriptEditorWithPath(editor)) return
+ const filePath = editor.getPath()
+ if (filePath === undefined) return
+
+ return {
+ range,
+ callback: async () => {
+ const location = {
+ file: filePath,
+ line: range.start.row + 1,
+ offset: range.start.column + 1,
+ }
+ const client = await getClient(location.file)
+ const result = await client.execute("definition", location)
+ await handleDefinitionResult(result, editor, histGoForward)
+ },
+ }
+ },
+ }
+}
diff --git a/lib/main/atom-ide/outlineProvider.ts b/lib/main/atom-ide/outlineProvider.ts
new file mode 100644
index 000000000..032a231f2
--- /dev/null
+++ b/lib/main/atom-ide/outlineProvider.ts
@@ -0,0 +1,91 @@
+import {OutlineProvider, OutlineTree, OutlineTreeKind} from "atom/ide"
+import {NavigationTree, ScriptElementKind} from "typescript/lib/protocol"
+import {GetClientFunction} from "../../client"
+import {spanToRange, typeScriptScopes} from "../atom/utils"
+
+export function getOutlineProvider(getClient: GetClientFunction): OutlineProvider {
+ return {
+ name: "Atom-TypeScript",
+ grammarScopes: typeScriptScopes(),
+ priority: 100,
+ updateOnEdit: true,
+ async getOutline(editor) {
+ const filePath = editor.getPath()
+ if (filePath === undefined) return
+ const client = await getClient(filePath)
+ const navTreeResult = await client.execute("navtree", {file: filePath})
+ const navTree = navTreeResult.body
+ if (!navTree) return
+ return {outlineTrees: [navTreeToOutline(navTree)]}
+ },
+ }
+}
+
+function navTreeToOutline(navTree: NavigationTree): OutlineTree {
+ const ranges = navTree.spans.map(spanToRange)
+ const range = ranges.reduce((prev, cur) => cur.union(prev))
+ return {
+ kind: kindMap[navTree.kind],
+ plainText: navTree.text,
+ startPosition: range.start,
+ endPosition: range.end,
+ landingPosition: navTree.nameSpan ? spanToRange(navTree.nameSpan).start : undefined,
+ children: navTree.childItems ? navTree.childItems.map(navTreeToOutline) : [],
+ }
+}
+
+const kindMap: {[key in ScriptElementKind]: OutlineTreeKind | undefined} = {
+ // | "file"
+ directory: "file",
+ // | "module"
+ module: "module",
+ "external module name": "module",
+ // | "namespace"
+ // | "package"
+ // | "class"
+ class: "class",
+ "local class": "class",
+ // | "method"
+ method: "method",
+ // | "property"
+ property: "property",
+ getter: "property",
+ setter: "property",
+ // | "field"
+ "JSX attribute": "field",
+ // | "constructor"
+ constructor: "constructor",
+ // | "enum"
+ enum: "enum",
+ // | "interface"
+ interface: "interface",
+ type: "interface",
+ // | "function"
+ function: "function",
+ "local function": "function",
+ // | "variable"
+ label: "variable",
+ alias: "variable",
+ var: "variable",
+ let: "variable",
+ "local var": "variable",
+ parameter: "variable",
+ // | "constant"
+ "enum member": "constant",
+ const: "constant",
+ // | "string"
+ string: "string",
+ // | "number"
+ // | "boolean"
+ // | "array"
+ // ???
+ "": undefined,
+ warning: undefined,
+ keyword: undefined,
+ script: undefined,
+ call: undefined,
+ index: undefined,
+ construct: undefined,
+ "type parameter": undefined,
+ "primitive type": undefined,
+}
diff --git a/lib/main/atom-ide/sigHelpProvider.ts b/lib/main/atom-ide/sigHelpProvider.ts
new file mode 100644
index 000000000..5d8449714
--- /dev/null
+++ b/lib/main/atom-ide/sigHelpProvider.ts
@@ -0,0 +1,42 @@
+import {Point, TextEditor} from "atom"
+import {SignatureHelp, SignatureHelpProvider} from "atom/ide"
+import {GetClientFunction} from "../../client"
+import {signatureHelpItemToSignature, typeScriptScopes} from "../atom/utils"
+import {FlushTypescriptBuffer} from "../pluginManager"
+
+export class TSSigHelpProvider implements SignatureHelpProvider {
+ public triggerCharacters = new Set
(["(", ","])
+ public grammarScopes = typeScriptScopes()
+ public priority = 100
+
+ constructor(
+ private getClient: GetClientFunction,
+ private flushTypescriptBuffer: FlushTypescriptBuffer,
+ ) {}
+
+ public async getSignatureHelp(
+ editor: TextEditor,
+ pos: Point,
+ ): Promise {
+ try {
+ const filePath = editor.getPath()
+ if (filePath === undefined) return
+ const client = await this.getClient(filePath)
+ await this.flushTypescriptBuffer(filePath)
+ const result = await client.execute("signatureHelp", {
+ file: filePath,
+ line: pos.row + 1,
+ offset: pos.column + 1,
+ })
+ const data = result.body!
+ const signatures = data.items.map(signatureHelpItemToSignature)
+ return {
+ signatures,
+ activeParameter: data.argumentIndex,
+ activeSignature: data.selectedItemIndex,
+ }
+ } catch (e) {
+ return
+ }
+ }
+}
diff --git a/lib/main/atom/autoCompleteProvider.ts b/lib/main/atom/autoCompleteProvider.ts
index bd36f8e32..90a524bc2 100644
--- a/lib/main/atom/autoCompleteProvider.ts
+++ b/lib/main/atom/autoCompleteProvider.ts
@@ -1,11 +1,10 @@
// more: https://github.com/atom-community/autocomplete-plus/wiki/Provider-API
-import {ClientResolver} from "../../client/clientResolver"
-import {FileLocationQuery, typeScriptScopes, spanToRange} from "./utils"
-import * as ACP from "atom/autocomplete-plus"
-import {TypescriptServiceClient} from "../../client/client"
import * as Atom from "atom"
+import * as ACP from "atom/autocomplete-plus"
import * as fuzzaldrin from "fuzzaldrin"
-import {WithTypescriptBuffer} from "../pluginManager"
+import {GetClientFunction, TSClient} from "../../client"
+import {FlushTypescriptBuffer} from "../pluginManager"
+import {FileLocationQuery, spanToRange, typeScriptScopes} from "./utils"
const importPathScopes = ["meta.import", "meta.import-equals", "triple-slash-directive"]
@@ -14,10 +13,6 @@ type SuggestionWithDetails = ACP.TextSuggestion & {
replacementRange?: Atom.Range
}
-interface Options {
- withTypescriptBuffer: WithTypescriptBuffer
-}
-
export class AutocompleteProvider implements ACP.AutocompleteProvider {
public selector = typeScriptScopes()
.map(x => (x.includes(".") ? `.${x}` : x))
@@ -26,13 +21,12 @@ export class AutocompleteProvider implements ACP.AutocompleteProvider {
public disableForSelector = ".comment"
public inclusionPriority = 3
- public suggestionPriority = atom.config.get("atom-typescript.autocompletionSuggestionPriority")
+ public suggestionPriority = atom.config.get("atom-typescript").autocompletionSuggestionPriority
public excludeLowerPriority = false
- private clientResolver: ClientResolver
private lastSuggestions?: {
// Client used to get the suggestions
- client: TypescriptServiceClient
+ client: TSClient
// File and position for the suggestions
location: FileLocationQuery
@@ -44,12 +38,10 @@ export class AutocompleteProvider implements ACP.AutocompleteProvider {
suggestions: SuggestionWithDetails[]
}
- private opts: Options
-
- constructor(clientResolver: ClientResolver, opts: Options) {
- this.clientResolver = clientResolver
- this.opts = opts
- }
+ constructor(
+ private getClient: GetClientFunction,
+ private flushTypescriptBuffer: FlushTypescriptBuffer,
+ ) {}
public async getSuggestions(opts: ACP.SuggestionsRequestedEvent): Promise {
const location = getLocationQuery(opts)
@@ -85,9 +77,7 @@ export class AutocompleteProvider implements ACP.AutocompleteProvider {
}
// Flush any pending changes for this buffer to get up to date completions
- await this.opts.withTypescriptBuffer(location.file, async buffer => {
- await buffer.flush()
- })
+ await this.flushTypescriptBuffer(location.file)
try {
let suggestions = await this.getSuggestionsWithCache(prefix, location, opts.activatedManually)
@@ -164,7 +154,7 @@ export class AutocompleteProvider implements ACP.AutocompleteProvider {
}
}
- const client = await this.clientResolver.get(location.file)
+ const client = await this.getClient(location.file)
const completions = await client.execute("completions", {
prefix,
includeExternalModuleExports: false,
@@ -245,35 +235,61 @@ function completionEntryToSuggestion(entry: protocol.CompletionEntry): Suggestio
text: entry.insertText !== undefined ? entry.insertText : entry.name,
leftLabel: entry.kind,
replacementRange: entry.replacementSpan ? spanToRange(entry.replacementSpan) : undefined,
- type: kindToType(entry.kind),
+ type: kindMap[entry.kind],
}
}
-/** See types :
+/** From :
* https://github.com/atom-community/autocomplete-plus/pull/334#issuecomment-85697409
*/
-export function kindToType(kind: string) {
- // variable, constant, property, value, method, function, class, type, keyword, tag, snippet, import, require
- switch (kind) {
- case "const":
- return "constant"
- case "interface":
- return "type"
- case "identifier":
- return "variable"
- case "local function":
- return "function"
- case "local var":
- return "variable"
- case "let":
- case "var":
- case "parameter":
- return "variable"
- case "alias":
- return "import"
- case "type parameter":
- return "type"
- default:
- return kind.split(" ")[0]
- }
+type ACPCompletionType =
+ | "variable"
+ | "constant"
+ | "property"
+ | "value"
+ | "method"
+ | "function"
+ | "class"
+ | "type"
+ | "keyword"
+ | "tag"
+ | "import"
+ | "require"
+ | "snippet"
+
+const kindMap: {[key in protocol.ScriptElementKind]: ACPCompletionType | undefined} = {
+ directory: "require",
+ module: "import",
+ "external module name": "import",
+ class: "class",
+ "local class": "class",
+ method: "method",
+ property: "property",
+ getter: "property",
+ setter: "property",
+ "JSX attribute": "property",
+ constructor: "method",
+ enum: "type",
+ interface: "type",
+ type: "type",
+ "type parameter": "type",
+ "primitive type": "type",
+ function: "function",
+ "local function": "function",
+ label: "variable",
+ alias: "import",
+ var: "variable",
+ let: "variable",
+ "local var": "variable",
+ parameter: "variable",
+ "enum member": "constant",
+ const: "constant",
+ string: "value",
+ keyword: "keyword",
+ "": undefined,
+ warning: undefined,
+ script: undefined,
+ call: undefined,
+ index: undefined,
+ construct: undefined,
}
diff --git a/lib/main/atom/codefix/codeActionsProvider.ts b/lib/main/atom/codefix/codeActionsProvider.ts
deleted file mode 100644
index 5d4b0429b..000000000
--- a/lib/main/atom/codefix/codeActionsProvider.ts
+++ /dev/null
@@ -1,46 +0,0 @@
-import * as Atom from "atom"
-import {CodefixProvider} from "./codefixProvider"
-import {typeScriptScopes} from "../utils"
-
-export interface Message {
- filePath: string
- range?: Atom.Range
- // this interface is rater obviously incomplete
-}
-
-export interface CodeAction {
- apply(): Promise
- getTitle(): Promise
- dispose(): void
-}
-
-export interface CodeActionProvider {
- grammarScopes: ReadonlyArray
- priority: number
- getCodeActions(
- editor: Atom.TextEditor,
- range: Atom.Range,
- diagnostics: Message[],
- ): Promise
-}
-
-export class CodeActionsProvider implements CodeActionProvider {
- public grammarScopes = typeScriptScopes()
- public priority = 0
-
- constructor(private codefixProvider: CodefixProvider) {}
-
- public async getCodeActions(
- textEditor: Atom.TextEditor,
- range: Atom.Range,
- _diagnostics: Message[],
- ): Promise {
- return (await this.codefixProvider.runCodeFix(textEditor, range.start)).map(fix => ({
- getTitle: async () => fix.description,
- dispose: () => {},
- apply: async () => {
- await this.codefixProvider.applyFix(fix)
- },
- }))
- }
-}
diff --git a/lib/main/atom/codefix/codefixProvider.ts b/lib/main/atom/codefix/codefixProvider.ts
index c09078edd..b8b4b918b 100644
--- a/lib/main/atom/codefix/codefixProvider.ts
+++ b/lib/main/atom/codefix/codefixProvider.ts
@@ -1,12 +1,11 @@
import * as Atom from "atom"
-import {ClientResolver} from "../../../client/clientResolver"
+import {ClientResolver, TSClient} from "../../../client"
import {ErrorPusher} from "../../errorPusher"
-import {pointToLocation} from "../utils"
-import {TypescriptServiceClient} from "../../../client/client"
import {ApplyEdits} from "../../pluginManager"
+import {spanToRange} from "../utils"
export class CodefixProvider {
- private supportedFixes: WeakMap> = new WeakMap()
+ private supportedFixes: WeakMap> = new WeakMap()
constructor(
private clientResolver: ClientResolver,
@@ -14,9 +13,23 @@ export class CodefixProvider {
private applyEdits: ApplyEdits,
) {}
+ public async getFixableRanges(textEditor: Atom.TextEditor, range: Atom.Range) {
+ const filePath = textEditor.getPath()
+ if (filePath === undefined) return []
+ const errors = this.errorPusher.getErrorsInRange(filePath, range)
+ const client = await this.clientResolver.get(filePath)
+ const supportedCodes = await this.getSupportedFixes(client)
+
+ const ranges = Array.from(errors)
+ .filter(error => error.code !== undefined && supportedCodes.has(error.code))
+ .map(error => spanToRange(error))
+
+ return ranges
+ }
+
public async runCodeFix(
textEditor: Atom.TextEditor,
- bufferPosition: Atom.PointLike,
+ bufferPosition: Atom.Point,
): Promise {
const filePath = textEditor.getPath()
@@ -25,8 +38,7 @@ export class CodefixProvider {
const client = await this.clientResolver.get(filePath)
const supportedCodes = await this.getSupportedFixes(client)
- const requests = this.errorPusher
- .getErrorsAt(filePath, pointToLocation(bufferPosition))
+ const requests = Array.from(this.errorPusher.getErrorsAt(filePath, bufferPosition))
.filter(error => error.code !== undefined && supportedCodes.has(error.code))
.map(error =>
client.execute("getCodeFixes", {
@@ -61,13 +73,13 @@ export class CodefixProvider {
// NOOP
}
- private async getSupportedFixes(client: TypescriptServiceClient) {
+ private async getSupportedFixes(client: TSClient) {
let codes = this.supportedFixes.get(client)
if (codes) {
return codes
}
- const result = await client.execute("getSupportedCodeFixes", undefined)
+ const result = await client.execute("getSupportedCodeFixes")
if (!result.body) {
throw new Error("No code fixes are supported")
diff --git a/lib/main/atom/codefix/index.ts b/lib/main/atom/codefix/index.ts
index e0ffa8b5d..e61327805 100644
--- a/lib/main/atom/codefix/index.ts
+++ b/lib/main/atom/codefix/index.ts
@@ -1,3 +1 @@
-export {CodeActionsProvider} from "./codeActionsProvider"
-export {IntentionsProvider} from "./intentionsProvider"
export {CodefixProvider} from "./codefixProvider"
diff --git a/lib/main/atom/codefix/intentionsProvider.ts b/lib/main/atom/codefix/intentionsProvider.ts
index 6f26e765e..d483bbdf8 100644
--- a/lib/main/atom/codefix/intentionsProvider.ts
+++ b/lib/main/atom/codefix/intentionsProvider.ts
@@ -1,4 +1,5 @@
import * as Atom from "atom"
+import {handlePromise} from "../../../utils"
import {CodefixProvider} from "./codefixProvider"
interface Intention {
@@ -9,31 +10,69 @@ interface Intention {
selected: () => void
}
+interface IntentionHighlight {
+ range: Atom.Range
+ created: (args: CreatedCallbackArgs) => void
+}
+
+interface CreatedCallbackArgs {
+ textEditor: Atom.TextEditor
+ element: HTMLElement
+ marker: Atom.DisplayMarker
+ matchedText: string
+}
+
interface IntentionsProviderInterface {
grammarScopes: string[]
getIntentions: (opts: GetIntentionsOptions) => Intention[] | Promise
}
+interface IntentionsHighlightsProviderInterface {
+ grammarScopes: string[]
+ getIntentions: (
+ opts: GetIntentionsHighlightsOptions,
+ ) => IntentionHighlight[] | Promise
+}
+
interface GetIntentionsOptions {
bufferPosition: Atom.Point
textEditor: Atom.TextEditor
}
-export class IntentionsProvider implements IntentionsProviderInterface {
- public grammarScopes = ["*"]
+interface GetIntentionsHighlightsOptions {
+ visibleRange: Atom.Range
+ textEditor: Atom.TextEditor
+}
- constructor(private codefixProvider: CodefixProvider) {}
+export function getIntentionsProvider(
+ codefixProvider: CodefixProvider,
+): IntentionsProviderInterface {
+ return {
+ grammarScopes: ["*"],
+ async getIntentions({bufferPosition, textEditor}) {
+ return (await codefixProvider.runCodeFix(textEditor, bufferPosition)).map(fix => ({
+ priority: 100,
+ title: fix.description,
+ selected: () => {
+ handlePromise(codefixProvider.applyFix(fix))
+ },
+ }))
+ },
+ }
+}
- public async getIntentions({
- bufferPosition,
- textEditor,
- }: GetIntentionsOptions): Promise {
- return (await this.codefixProvider.runCodeFix(textEditor, bufferPosition)).map(fix => ({
- priority: 100,
- title: fix.description,
- selected: () => {
- this.codefixProvider.applyFix(fix)
- },
- }))
+export function getIntentionsHighlightsProvider(
+ codefixProvider: CodefixProvider,
+): IntentionsHighlightsProviderInterface {
+ return {
+ grammarScopes: ["*"],
+ async getIntentions({visibleRange, textEditor}) {
+ return (await codefixProvider.getFixableRanges(textEditor, visibleRange)).map(range => ({
+ range,
+ created: (_opts: CreatedCallbackArgs) => {
+ // NOOP
+ },
+ }))
+ },
}
}
diff --git a/lib/main/atom/commands/build.ts b/lib/main/atom/commands/build.ts
index 0af4b8197..5d0fb36be 100644
--- a/lib/main/atom/commands/build.ts
+++ b/lib/main/atom/commands/build.ts
@@ -7,6 +7,8 @@ addCommand("atom-text-editor", "typescript:build", deps => ({
if (file === undefined) return
const client = await deps.getClient(file)
+ deps.reportBuildStatus(undefined)
+
const projectInfo = await client.execute("projectInfo", {
file,
needFileNameList: true,
@@ -15,11 +17,10 @@ addCommand("atom-text-editor", "typescript:build", deps => ({
const files = new Set(projectInfo.body!.fileNames)
files.delete(projectInfo.body!.configFileName)
let filesSoFar = 0
- const stp = deps.getStatusPanel()
const promises = [...files.values()].map(f =>
_finally(client.execute("compileOnSaveEmitFile", {file: f, forced: true}), () => {
- stp.update({progress: {max: files.size, value: (filesSoFar += 1)}})
- if (files.size <= filesSoFar) stp.update({progress: undefined})
+ filesSoFar += 1
+ deps.reportProgress({max: files.size, value: filesSoFar})
}),
)
@@ -28,11 +29,11 @@ addCommand("atom-text-editor", "typescript:build", deps => ({
if (results.some(result => result.body === false)) {
throw new Error("Emit failed")
}
- stp.update({buildStatus: {success: true}})
+ deps.reportBuildStatus({success: true})
} catch (error) {
const err = error as Error
console.error(err)
- stp.update({buildStatus: {success: false, message: err.message}})
+ deps.reportBuildStatus({success: false, message: err.message})
}
},
}))
diff --git a/lib/main/atom/commands/checkAllFiles.ts b/lib/main/atom/commands/checkAllFiles.ts
index fc65066c0..0d5e88941 100644
--- a/lib/main/atom/commands/checkAllFiles.ts
+++ b/lib/main/atom/commands/checkAllFiles.ts
@@ -23,16 +23,14 @@ addCommand("atom-text-editor", "typescript:check-all-files", deps => ({
const disp = client.on("syntaxDiag", evt => {
if (cancelTimeout !== undefined) window.clearTimeout(cancelTimeout)
- cancelTimeout = window.setTimeout(cancel, 500)
+ cancelTimeout = window.setTimeout(cancel, 2000)
files.delete(evt.file)
updateStatus()
})
- const stp = deps.getStatusPanel()
-
- stp.update({progress: {max, value: 0}})
- client.execute("geterrForProject", {file, delay: 0})
+ deps.reportProgress({max, value: 0})
+ await client.execute("geterrForProject", {file, delay: 0})
function cancel() {
files.clear()
@@ -40,12 +38,8 @@ addCommand("atom-text-editor", "typescript:check-all-files", deps => ({
}
function updateStatus() {
- if (files.size === 0) {
- disp.dispose()
- stp.update({progress: undefined})
- } else {
- stp.update({progress: {max, value: max - files.size}})
- }
+ if (files.size === 0) disp.dispose()
+ deps.reportProgress({max, value: max - files.size})
}
},
}))
diff --git a/lib/main/atom/commands/clearErrors.ts b/lib/main/atom/commands/clearErrors.ts
index 243d21563..b0afce891 100644
--- a/lib/main/atom/commands/clearErrors.ts
+++ b/lib/main/atom/commands/clearErrors.ts
@@ -6,13 +6,3 @@ addCommand("atom-workspace", "typescript:clear-errors", deps => ({
deps.clearErrors()
},
}))
-
-addCommand("atom-text-editor", "typescript:reload-projects", deps => ({
- description: "Reload projects",
- async didDispatch(editor) {
- const path = editor.getPath()
- if (path === undefined) return
- const client = await deps.getClient(path)
- client.execute("reloadProjects", undefined)
- },
-}))
diff --git a/lib/main/atom/commands/findReferences.tsx b/lib/main/atom/commands/findReferences.tsx
index af155ef08..843417dd4 100644
--- a/lib/main/atom/commands/findReferences.tsx
+++ b/lib/main/atom/commands/findReferences.tsx
@@ -1,9 +1,9 @@
-import {addCommand} from "./registry"
-import {getFilePathPosition} from "../utils"
-import {selectListView} from "../views/simpleSelectionView"
import * as etch from "etch"
import {TsView} from "../components/tsView"
+import {getFilePathPosition} from "../utils"
import {HighlightComponent} from "../views/highlightComponent"
+import {selectListView} from "../views/simpleSelectionView"
+import {addCommand} from "./registry"
addCommand("atom-text-editor", "typescript:find-references", deps => ({
description: "Find where symbol under text cursor is referenced",
@@ -30,6 +30,6 @@ addCommand("atom-text-editor", "typescript:find-references", deps => ({
},
itemFilterKey: "file",
})
- if (res) deps.getEditorPositionHistoryManager().goForward(editor, res)
+ if (res) await deps.histGoForward(editor, res)
},
}))
diff --git a/lib/main/atom/commands/formatCode.ts b/lib/main/atom/commands/formatCode.ts
index f83f4cab8..6ed224548 100644
--- a/lib/main/atom/commands/formatCode.ts
+++ b/lib/main/atom/commands/formatCode.ts
@@ -1,6 +1,6 @@
-import {addCommand} from "./registry"
-import {CodeEdit, LocationRangeQuery, rangeToLocationRange, spanToRange} from "../utils"
import {TextEditor} from "atom"
+import {CodeEdit, LocationRangeQuery, rangeToLocationRange, spanToRange} from "../utils"
+import {addCommand} from "./registry"
addCommand("atom-text-editor", "typescript:format-code", deps => ({
description: "Format code in currently active text editor",
diff --git a/lib/main/atom/commands/goToDeclaration.tsx b/lib/main/atom/commands/goToDeclaration.tsx
index 54edd05e6..416285d20 100644
--- a/lib/main/atom/commands/goToDeclaration.tsx
+++ b/lib/main/atom/commands/goToDeclaration.tsx
@@ -1,10 +1,9 @@
-import {addCommand} from "./registry"
-import {getFilePathPosition} from "../utils"
-import {selectListView} from "../views/simpleSelectionView"
+import {TextEditor} from "atom"
import * as etch from "etch"
+import {getFilePathPosition} from "../utils"
import {HighlightComponent} from "../views/highlightComponent"
-import {TextEditor} from "atom"
-import {EditorPositionHistoryManager} from "../editorPositionHistoryManager"
+import {selectListView} from "../views/simpleSelectionView"
+import {addCommand, Dependencies} from "./registry"
addCommand("atom-text-editor", "typescript:go-to-declaration", deps => ({
description: "Go to declaration of symbol under text cursor",
@@ -14,14 +13,14 @@ addCommand("atom-text-editor", "typescript:go-to-declaration", deps => ({
const client = await deps.getClient(location.file)
const result = await client.execute("definition", location)
- handleDefinitionResult(result, editor, deps.getEditorPositionHistoryManager())
+ await handleDefinitionResult(result, editor, deps.histGoForward)
},
}))
export async function handleDefinitionResult(
result: protocol.DefinitionResponse,
editor: TextEditor,
- hist: EditorPositionHistoryManager,
+ histGoForward: Dependencies["histGoForward"],
): Promise {
if (!result.body) {
return
@@ -38,8 +37,8 @@ export async function handleDefinitionResult(
},
itemFilterKey: "file",
})
- if (res) hist.goForward(editor, res)
+ if (res) await histGoForward(editor, res)
} else if (result.body.length > 0) {
- hist.goForward(editor, result.body[0])
+ await histGoForward(editor, result.body[0])
}
}
diff --git a/lib/main/atom/commands/hideSigHelp.ts b/lib/main/atom/commands/hideSigHelp.ts
new file mode 100644
index 000000000..8532072b1
--- /dev/null
+++ b/lib/main/atom/commands/hideSigHelp.ts
@@ -0,0 +1,8 @@
+import {addCommand} from "./registry"
+
+addCommand("atom-text-editor", "typescript:hide-signature-help", deps => ({
+ description: "Hide the currently visible signature help",
+ async didDispatch(ed, ignore) {
+ if (!deps.hideSigHelpAt(ed)) ignore()
+ },
+}))
diff --git a/lib/main/atom/commands/index.ts b/lib/main/atom/commands/index.ts
index ebf5394bd..e36674831 100644
--- a/lib/main/atom/commands/index.ts
+++ b/lib/main/atom/commands/index.ts
@@ -1,24 +1,28 @@
-import {getCommands, Dependencies} from "./registry"
-import {CompositeDisposable} from "atom"
+import {CompositeDisposable, DisposableLike} from "atom"
import {isTypescriptEditorWithPath, isTypescriptGrammar} from "../utils"
+import {Dependencies, getCommands} from "./registry"
// Import all of the command files for their side effects
import "./build"
import "./checkAllFiles"
import "./clearErrors"
-import "./formatCode"
import "./findReferences"
+import "./formatCode"
import "./goToDeclaration"
-import "./returnFromDeclaration"
-import "./renameRefactor"
-import "./showTooltip"
+import "./hideSigHelp"
import "./initializeConfig"
+import "./organizeImports"
+import "./refactorCode"
+import "./reloadProjects"
+import "./renameRefactor"
+import "./restartAllServers"
+import "./returnFromDeclaration"
import "./semanticView"
+import "./showSigHelp"
+import "./showTooltip"
import "./symbolsView"
-import "./refactorCode"
-import "./organizeImports"
-export function registerCommands(deps: Dependencies) {
+export function registerCommands(deps: Dependencies): DisposableLike {
const disp = new CompositeDisposable()
for (const cmd of getCommands()) {
if (cmd.selector === "atom-text-editor") {
@@ -54,16 +58,18 @@ export function registerCommands(deps: Dependencies) {
)
} else {
const d = cmd.desc(deps)
- atom.commands.add(cmd.selector, cmd.command, {
- ...d,
- async didDispatch() {
- try {
- await d.didDispatch()
- } catch (error) {
- handle(error as Error)
- }
- },
- })
+ disp.add(
+ atom.commands.add(cmd.selector, cmd.command, {
+ ...d,
+ async didDispatch() {
+ try {
+ await d.didDispatch()
+ } catch (error) {
+ handle(error as Error)
+ }
+ },
+ }),
+ )
}
}
return disp
diff --git a/lib/main/atom/commands/initializeConfig.ts b/lib/main/atom/commands/initializeConfig.ts
index ca7256f0b..adb7a4e89 100644
--- a/lib/main/atom/commands/initializeConfig.ts
+++ b/lib/main/atom/commands/initializeConfig.ts
@@ -1,6 +1,6 @@
-import {addCommand} from "./registry"
-import {resolveBinary} from "../../../client/clientResolver"
import {BufferedNodeProcess} from "atom"
+import {resolveBinary} from "../../../client"
+import {addCommand} from "./registry"
addCommand("atom-text-editor", "typescript:initialize-config", () => ({
description: "Create tsconfig.json in the project related to currently-active text edtior",
@@ -24,21 +24,26 @@ addCommand("atom-text-editor", "typescript:initialize-config", () => ({
},
}))
-function initConfig(tsc: string, projectRoot: string): Promise {
- return new Promise((resolve, reject) => {
- try {
- const bnp = new BufferedNodeProcess({
- command: tsc,
- args: ["--init"],
- options: {cwd: projectRoot},
- exit: code => {
- if (code === 0) resolve()
- else reject(new Error(`Tsc ended with nonzero exit code ${code}`))
- },
- })
- bnp.onWillThrowError(reject)
- } catch (e) {
- reject(e)
- }
- })
+async function initConfig(tsc: string, projectRoot: string): Promise {
+ let disp: {dispose: () => void} | undefined
+ try {
+ return await new Promise((resolve, reject) => {
+ try {
+ const bnp = new BufferedNodeProcess({
+ command: tsc,
+ args: ["--init"],
+ options: {cwd: projectRoot},
+ exit: code => {
+ if (code === 0) resolve()
+ else reject(new Error(`Tsc ended with nonzero exit code ${code}`))
+ },
+ })
+ disp = bnp.onWillThrowError(reject)
+ } catch (e) {
+ reject(e)
+ }
+ })
+ } finally {
+ if (disp) disp.dispose()
+ }
}
diff --git a/lib/main/atom/commands/refactorCode.tsx b/lib/main/atom/commands/refactorCode.tsx
index efaf4e834..e848d7056 100644
--- a/lib/main/atom/commands/refactorCode.tsx
+++ b/lib/main/atom/commands/refactorCode.tsx
@@ -1,10 +1,10 @@
-import {addCommand, Dependencies} from "./registry"
-import {getFilePathPosition} from "../utils"
-import {selectListView} from "../views/simpleSelectionView"
import * as etch from "etch"
-import {HighlightComponent} from "../views/highlightComponent"
import * as protocol from "typescript/lib/protocol"
-import {TypescriptServiceClient} from "../../../client/client"
+import {TSClient} from "../../../client"
+import {getFilePathPosition} from "../utils"
+import {HighlightComponent} from "../views/highlightComponent"
+import {selectListView} from "../views/simpleSelectionView"
+import {addCommand, Dependencies} from "./registry"
interface RefactorAction {
refactorName: string
@@ -61,7 +61,7 @@ addCommand("atom-text-editor", "typescript:refactor-selection", deps => ({
}))
async function getApplicableRefactorsActions(
- client: TypescriptServiceClient,
+ client: TSClient,
pointOrRange: protocol.FileLocationOrRangeRequestArgs,
) {
const responseApplicable = await getApplicabeRefactors(client, pointOrRange)
@@ -87,7 +87,7 @@ async function getApplicableRefactorsActions(
}
async function getApplicabeRefactors(
- client: TypescriptServiceClient,
+ client: TSClient,
pointOrRange: protocol.FileLocationOrRangeRequestArgs,
) {
try {
@@ -100,7 +100,7 @@ async function getApplicabeRefactors(
async function applyRefactors(
selectedAction: RefactorAction,
range: protocol.FileLocationOrRangeRequestArgs,
- client: TypescriptServiceClient,
+ client: TSClient,
deps: Dependencies,
) {
const responseEdits = await client.execute("getEditsForRefactor", {
diff --git a/lib/main/atom/commands/registry.ts b/lib/main/atom/commands/registry.ts
index 3000c2408..fba6f9cb2 100644
--- a/lib/main/atom/commands/registry.ts
+++ b/lib/main/atom/commands/registry.ts
@@ -1,19 +1,25 @@
import * as Atom from "atom"
-import {TypescriptServiceClient} from "../../../client/client"
-import {StatusPanel} from "../../atom/components/statusPanel"
-import {SemanticViewController} from "../views/outline/semanticViewController"
-import {SymbolsViewController} from "../views/symbols/symbolsViewController"
+import {GetClientFunction} from "../../../client"
import {ApplyEdits} from "../../pluginManager"
-import {EditorPositionHistoryManager} from "../editorPositionHistoryManager"
+import {TBuildStatus, TProgress} from "../components/statusPanel"
+import {OpenParams} from "../editorPositionHistoryManager"
export interface Dependencies {
+ getClient: GetClientFunction
applyEdits: ApplyEdits
- clearErrors(): void
- getClient(filePath: string): Promise
- getStatusPanel(): StatusPanel
- getSemanticViewController(): SemanticViewController
- getSymbolsViewController(): SymbolsViewController
- getEditorPositionHistoryManager(): EditorPositionHistoryManager
+ clearErrors: () => void
+ killAllServers: () => void
+ reportProgress: (progress: TProgress) => void
+ reportBuildStatus: (status: TBuildStatus | undefined) => void
+ toggleSemanticViewController: () => void
+ toggleFileSymbolsView: (ed: Atom.TextEditor) => void
+ toggleProjectSymbolsView: (ed: Atom.TextEditor) => void
+ histGoForward: (ed: Atom.TextEditor, openParams: OpenParams) => Promise