development/vscode
development/vscode
1
0
Fork 0
mirror of https://github.com/Microsoft/vscode synced 2024-09-19 18:48:00 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/master' into snap

Browse source
This commit is contained in:
Joao Moreno 2018-11-08 15:21:27 +00:00
parent 5c3e3ec85a 1c3d278021
commit e4f9cae949
232 changed files with 3472 additions and 2175 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
.github/commands.yml vendored
View file

@ -46,6 +46,7 @@
{
type: 'comment',
name: 'duplicate',
allowUsers: ['cleidigh', 'usernamehw'],
action: 'updateLabels',
addLabel: '*duplicate'
},
@ -59,18 +60,21 @@
{
type: 'comment',
name: 'confirm',
allowUsers: ['cleidigh', 'usernamehw'],
action: 'updateLabels',
addLabel: 'confirmed'
},
{
type: 'comment',
name: 'findDuplicates',
allowUsers: ['cleidigh', 'usernamehw'],
action: 'comment',
comment: "Potential duplicates:\n${potentialDuplicates}"
},
{
type: 'comment',
name: 'needsMoreInfo',
allowUsers: ['cleidigh', 'usernamehw'],
action: 'updateLabels',
addLabel: 'needs more info',
comment: "Thanks for creating this issue! We figured it's missing some basic information or in some other way doesn't follow our [issue reporting](https://aka.ms/vscodeissuereporting) guidelines. Please take the time to review these and update the issue.\n\nHappy Coding!"

2
.vscode/shared.code-snippets vendored
View file

@ -31,7 +31,7 @@
"prefix": "emitter",
"description": "Add emitter and event properties",
"body": [
"private _onDid$1 = new Emitter<$2>();",
"private readonly _onDid$1 = new Emitter<$2>();",
"readonly onDid$1: Event<$2> = this._onDid$1.event;"
],
}

16
build/lib/extensions.js
View file

@ -36,10 +36,12 @@ function fromLocalWebpack(extensionPath, sourceMappingURLBase) {
const result = es.through();
const packagedDependencies = [];
const packageJsonConfig = require(path.join(extensionPath, 'package.json'));
const webpackRootConfig = require(path.join(extensionPath, 'extension.webpack.config.js'));
for (const key in webpackRootConfig.externals) {
if (key in packageJsonConfig.dependencies) {
packagedDependencies.push(key);
if (Array.isArray(packageJsonConfig.dependencies)) {
const webpackRootConfig = require(path.join(extensionPath, 'extension.webpack.config.js'));
for (const key in webpackRootConfig.externals) {
if (key in packageJsonConfig.dependencies) {
packagedDependencies.push(key);
}
}
}
vsce.listFiles({ cwd: extensionPath, packageManager: vsce.PackageManager.Yarn, packagedDependencies }).then(fileNames => {
@ -68,8 +70,10 @@ function fromLocalWebpack(extensionPath, sourceMappingURLBase) {
.pipe(packageJsonFilter)
.pipe(buffer())
.pipe(json((data) => {
// hardcoded entry point directory!
data.main = data.main.replace('/out/', /dist/);
if (data.main) {
// hardcoded entry point directory!
data.main = data.main.replace('/out/', /dist/);
}
return data;
}))
.pipe(packageJsonFilter.restore);

17
build/lib/extensions.ts
View file

@ -39,14 +39,15 @@ function fromLocalWebpack(extensionPath: string, sourceMappingURLBase: string |
const packagedDependencies: string[] = [];
const packageJsonConfig = require(path.join(extensionPath, 'package.json'));
const webpackRootConfig = require(path.join(extensionPath, 'extension.webpack.config.js'));
for (const key in webpackRootConfig.externals) {
if (key in packageJsonConfig.dependencies) {
packagedDependencies.push(key);
if (Array.isArray(packageJsonConfig.dependencies)) {
const webpackRootConfig = require(path.join(extensionPath, 'extension.webpack.config.js'));
for (const key in webpackRootConfig.externals) {
if (key in packageJsonConfig.dependencies) {
packagedDependencies.push(key);
}
}
}
vsce.listFiles({ cwd: extensionPath, packageManager: vsce.PackageManager.Yarn, packagedDependencies }).then(fileNames => {
const files = fileNames
.map(fileName => path.join(extensionPath, fileName))
@ -80,8 +81,10 @@ function fromLocalWebpack(extensionPath: string, sourceMappingURLBase: string |
.pipe(packageJsonFilter)
.pipe(buffer())
.pipe(json((data: any) => {
// hardcoded entry point directory!
data.main = data.main.replace('/out/', /dist/);
if (data.main) {
// hardcoded entry point directory!
data.main = data.main.replace('/out/', /dist/);
}
return data;
}))
.pipe(packageJsonFilter.restore);

4
extensions/git/src/api/api1.ts
View file

@ -128,8 +128,8 @@ export class ApiRepository implements Repository {
return this._repository.branch(name, checkout, ref);
}
deleteBranch(name: string): Promise<void> {
return this._repository.deleteBranch(name);
deleteBranch(name: string, force?: boolean): Promise<void> {
return this._repository.deleteBranch(name, force);
}
getBranch(name: string): Promise<Branch> {

2
extensions/git/src/api/git.d.ts vendored
View file

@ -138,7 +138,7 @@ export interface Repository {
hashObject(data: string): Promise<string>;
createBranch(name: string, checkout: boolean, ref?: string): Promise<void>;
deleteBranch(name: string): Promise<void>;
deleteBranch(name: string, force?: boolean): Promise<void>;
getBranch(name: string): Promise<Branch>;
setBranchUpstream(name: string, upstream: string): Promise<void>;

17
extensions/make/test/colorize-fixtures/makefile
View file

@ -25,10 +25,16 @@ hello.o: hello.cpp \
clean:
rm *o hello
.PHONY: all
all:
# "$$" in a shell means to escape makefile's variable substitution.
some_shell_var=$$(sed -nre 's/some regex with (group)/\1/p')
.PHONY: echo
echo:
echo "#" and '#' in quotes are not comments \
and '\' will be continued
define defined
$(info Checking existance of $(1) $(flavor $(1)))
$(if $(filter undefined,$(flavor $(1))),0,1)
@ -54,3 +60,14 @@ ifeq ("${ok}", "skip")
$(ok))}
${ok}})
endif
result != echo "'$(ok)' $(shell echo "from inlined shell")"
$(info $(result))
# Below is a test of variable assignment without any spacing.
var=val
var?=val
var:=123
var!=echo val
var:=val \
notvar=butval

726
extensions/make/test/colorize-results/makefile.json
View file

@ -714,6 +714,39 @@
"hc_black": "default: #FFFFFF"
}
},
{
"c": ".PHONY",
"t": "source.makefile meta.scope.target.makefile support.function.target.PHONY.makefile",
"r": {
"dark_plus": "support.function: #DCDCAA",
"light_plus": "support.function: #795E26",
"dark_vs": "default: #D4D4D4",
"light_vs": "default: #000000",
"hc_black": "support.function: #DCDCAA"
}
},
{
"c": ":",
"t": "source.makefile meta.scope.target.makefile punctuation.separator.key-value.makefile",
"r": {
"dark_plus": "default: #D4D4D4",
"light_plus": "default: #000000",
"dark_vs": "default: #D4D4D4",
"light_vs": "default: #000000",
"hc_black": "default: #FFFFFF"
}
},
{
"c": " all",
"t": "source.makefile meta.scope.target.makefile meta.scope.prerequisites.makefile",
"r": {
"dark_plus": "default: #D4D4D4",
"light_plus": "default: #000000",
"dark_vs": "default: #D4D4D4",
"light_vs": "default: #000000",
"hc_black": "default: #FFFFFF"
}
},
{
"c": "all",
"t": "source.makefile meta.scope.target.makefile entity.name.function.target.makefile",
@ -857,6 +890,270 @@
"hc_black": "default: #FFFFFF"
}
},
{
"c": ".PHONY",
"t": "source.makefile meta.scope.target.makefile support.function.target.PHONY.makefile",
"r": {
"dark_plus": "support.function: #DCDCAA",
"light_plus": "support.function: #795E26",
"dark_vs": "default: #D4D4D4",
"light_vs": "default: #000000",
"hc_black": "support.function: #DCDCAA"
}
},
{
"c": ":",
"t": "source.makefile meta.scope.target.makefile punctuation.separator.key-value.makefile",
"r": {
"dark_plus": "default: #D4D4D4",
"light_plus": "default: #000000",
"dark_vs": "default: #D4D4D4",
"light_vs": "default: #000000",
"hc_black": "default: #FFFFFF"
}
},
{
"c": " echo",
"t": "source.makefile meta.scope.target.makefile meta.scope.prerequisites.makefile",
"r": {
"dark_plus": "default: #D4D4D4",
"light_plus": "default: #000000",
"dark_vs": "default: #D4D4D4",
"light_vs": "default: #000000",
"hc_black": "default: #FFFFFF"
}
},
{
"c": "echo",
"t": "source.makefile meta.scope.target.makefile entity.name.function.target.makefile",
"r": {
"dark_plus": "entity.name.function: #DCDCAA",
"light_plus": "entity.name.function: #795E26",
"dark_vs": "default: #D4D4D4",
"light_vs": "default: #000000",
"hc_black": "entity.name.function: #DCDCAA"
}
},
{
"c": ":",
"t": "source.makefile meta.scope.target.makefile punctuation.separator.key-value.makefile",
"r": {
"dark_plus": "default: #D4D4D4",
"light_plus": "default: #000000",
"dark_vs": "default: #D4D4D4",
"light_vs": "default: #000000",
"hc_black": "default: #FFFFFF"
}
},
{
"c": "\t",
"t": "source.makefile meta.scope.recipe.makefile",
"r": {
"dark_plus": "default: #D4D4D4",
"light_plus": "default: #000000",
"dark_vs": "default: #D4D4D4",
"light_vs": "default: #000000",
"hc_black": "default: #FFFFFF"
}
},
{
"c": "echo",
"t": "source.makefile meta.scope.recipe.makefile support.function.builtin.shell",
"r": {
"dark_plus": "support.function: #DCDCAA",
"light_plus": "support.function: #795E26",
"dark_vs": "default: #D4D4D4",
"light_vs": "default: #000000",
"hc_black": "support.function: #DCDCAA"
}
},
{
"c": " ",
"t": "source.makefile meta.scope.recipe.makefile",
"r": {
"dark_plus": "default: #D4D4D4",
"light_plus": "default: #000000",
"dark_vs": "default: #D4D4D4",
"light_vs": "default: #000000",
"hc_black": "default: #FFFFFF"
}
},
{
"c": "\"",
"t": "source.makefile meta.scope.recipe.makefile string.quoted.double.shell punctuation.definition.string.begin.shell",
"r": {
"dark_plus": "string: #CE9178",
"light_plus": "string: #A31515",
"dark_vs": "string: #CE9178",
"light_vs": "string: #A31515",
"hc_black": "string: #CE9178"
}
},
{
"c": "#",
"t": "source.makefile meta.scope.recipe.makefile string.quoted.double.shell",
"r": {
"dark_plus": "string: #CE9178",
"light_plus": "string: #A31515",
"dark_vs": "string: #CE9178",
"light_vs": "string: #A31515",
"hc_black": "string: #CE9178"
}
},
{
"c": "\"",
"t": "source.makefile meta.scope.recipe.makefile string.quoted.double.shell punctuation.definition.string.end.shell",
"r": {
"dark_plus": "string: #CE9178",
"light_plus": "string: #A31515",
"dark_vs": "string: #CE9178",
"light_vs": "string: #A31515",
"hc_black": "string: #CE9178"
}
},
{
"c": " and ",
"t": "source.makefile meta.scope.recipe.makefile",
"r": {
"dark_plus": "default: #D4D4D4",
"light_plus": "default: #000000",
"dark_vs": "default: #D4D4D4",
"light_vs": "default: #000000",
"hc_black": "default: #FFFFFF"
}
},
{
"c": "'",
"t": "source.makefile meta.scope.recipe.makefile string.quoted.single.shell punctuation.definition.string.begin.shell",
"r": {
"dark_plus": "string: #CE9178",
"light_plus": "string: #A31515",
"dark_vs": "string: #CE9178",
"light_vs": "string: #A31515",
"hc_black": "string: #CE9178"
}
},
{
"c": "#",
"t": "source.makefile meta.scope.recipe.makefile string.quoted.single.shell",
"r": {
"dark_plus": "string: #CE9178",
"light_plus": "string: #A31515",
"dark_vs": "string: #CE9178",
"light_vs": "string: #A31515",
"hc_black": "string: #CE9178"
}
},
{
"c": "'",
"t": "source.makefile meta.scope.recipe.makefile string.quoted.single.shell punctuation.definition.string.end.shell",
"r": {
"dark_plus": "string: #CE9178",
"light_plus": "string: #A31515",
"dark_vs": "string: #CE9178",
"light_vs": "string: #A31515",
"hc_black": "string: #CE9178"
}
},
{
"c": " ",
"t": "source.makefile meta.scope.recipe.makefile",
"r": {
"dark_plus": "default: #D4D4D4",
"light_plus": "default: #000000",
"dark_vs": "default: #D4D4D4",
"light_vs": "default: #000000",
"hc_black": "default: #FFFFFF"
}
},
{
"c": "in",
"t": "source.makefile meta.scope.recipe.makefile keyword.control.shell",
"r": {
"dark_plus": "keyword.control: #C586C0",
"light_plus": "keyword.control: #AF00DB",
"dark_vs": "keyword.control: #569CD6",
"light_vs": "keyword.control: #0000FF",
"hc_black": "keyword.control: #C586C0"
}
},
{
"c": " quotes are not comments ",
"t": "source.makefile meta.scope.recipe.makefile",
"r": {
"dark_plus": "default: #D4D4D4",
"light_plus": "default: #000000",
"dark_vs": "default: #D4D4D4",
"light_vs": "default: #000000",
"hc_black": "default: #FFFFFF"
}
},
{
"c": "\\",
"t": "source.makefile meta.scope.recipe.makefile constant.character.escape.continuation.makefile",
"r": {
"dark_plus": "constant.character.escape: #D7BA7D",
"light_plus": "constant.character.escape: #FF0000",
"dark_vs": "default: #D4D4D4",
"light_vs": "default: #000000",
"hc_black": "constant.character: #569CD6"
}
},
{
"c": "\t\tand ",
"t": "source.makefile meta.scope.recipe.makefile",
"r": {
"dark_plus": "default: #D4D4D4",
"light_plus": "default: #000000",
"dark_vs": "default: #D4D4D4",
"light_vs": "default: #000000",
"hc_black": "default: #FFFFFF"
}
},
{
"c": "'",
"t": "source.makefile meta.scope.recipe.makefile string.quoted.single.shell punctuation.definition.string.begin.shell",
"r": {
"dark_plus": "string: #CE9178",
"light_plus": "string: #A31515",
"dark_vs": "string: #CE9178",
"light_vs": "string: #A31515",
"hc_black": "string: #CE9178"
}
},
{
"c": "\\",
"t": "source.makefile meta.scope.recipe.makefile string.quoted.single.shell",
"r": {
"dark_plus": "string: #CE9178",
"light_plus": "string: #A31515",
"dark_vs": "string: #CE9178",
"light_vs": "string: #A31515",
"hc_black": "string: #CE9178"
}
},
{
"c": "'",
"t": "source.makefile meta.scope.recipe.makefile string.quoted.single.shell punctuation.definition.string.end.shell",
"r": {
"dark_plus": "string: #CE9178",
"light_plus": "string: #A31515",
"dark_vs": "string: #CE9178",
"light_vs": "string: #A31515",
"hc_black": "string: #CE9178"
}
},
{
"c": " will be continued",
"t": "source.makefile meta.scope.recipe.makefile",
"r": {
"dark_plus": "default: #D4D4D4",
"light_plus": "default: #000000",
"dark_vs": "default: #D4D4D4",
"light_vs": "default: #000000",
"hc_black": "default: #FFFFFF"
}
},
{
"c": "define",
"t": "source.makefile meta.scope.conditional.makefile keyword.control.define.makefile",
@ -2286,5 +2583,434 @@
"light_vs": "keyword.control: #0000FF",
"hc_black": "keyword.control: #C586C0"
}
},
{
"c": "result",
"t": "source.makefile variable.other.makefile",
"r": {
"dark_plus": "variable: #9CDCFE",
"light_plus": "variable: #001080",
"dark_vs": "default: #D4D4D4",
"light_vs": "default: #000000",
"hc_black": "variable: #9CDCFE"
}
},
{
"c": " ",
"t": "source.makefile",
"r": {
"dark_plus": "default: #D4D4D4",
"light_plus": "default: #000000",
"dark_vs": "default: #D4D4D4",
"light_vs": "default: #000000",
"hc_black": "default: #FFFFFF"
}
},
{
"c": "!=",
"t": "source.makefile punctuation.separator.key-value.makefile",
"r": {
"dark_plus": "default: #D4D4D4",
"light_plus": "default: #000000",
"dark_vs": "default: #D4D4D4",
"light_vs": "default: #000000",
"hc_black": "default: #FFFFFF"
}
},
{
"c": " echo \"'",
"t": "source.makefile",
"r": {
"dark_plus": "default: #D4D4D4",
"light_plus": "default: #000000",
"dark_vs": "default: #D4D4D4",
"light_vs": "default: #000000",
"hc_black": "default: #FFFFFF"
}
},
{
"c": "$(",
"t": "source.makefile string.interpolated.makefile punctuation.definition.variable.makefile",
"r": {
"dark_plus": "string: #CE9178",
"light_plus": "string: #A31515",
"dark_vs": "string: #CE9178",
"light_vs": "string: #A31515",
"hc_black": "string: #CE9178"
}
},
{
"c": "ok",
"t": "source.makefile string.interpolated.makefile variable.other.makefile",
"r": {
"dark_plus": "variable: #9CDCFE",
"light_plus": "variable: #001080",
"dark_vs": "string: #CE9178",
"light_vs": "string: #A31515",
"hc_black": "variable: #9CDCFE"
}
},
{
"c": ")",
"t": "source.makefile string.interpolated.makefile punctuation.definition.variable.makefile",
"r": {
"dark_plus": "string: #CE9178",
"light_plus": "string: #A31515",
"dark_vs": "string: #CE9178",
"light_vs": "string: #A31515",
"hc_black": "string: #CE9178"
}
},
{
"c": "' ",
"t": "source.makefile",
"r": {
"dark_plus": "default: #D4D4D4",
"light_plus": "default: #000000",
"dark_vs": "default: #D4D4D4",
"light_vs": "default: #000000",
"hc_black": "default: #FFFFFF"
}
},
{
"c": "$(",
"t": "source.makefile string.interpolated.makefile punctuation.definition.variable.makefile",
"r": {
"dark_plus": "string: #CE9178",
"light_plus": "string: #A31515",
"dark_vs": "string: #CE9178",
"light_vs": "string: #A31515",
"hc_black": "string: #CE9178"
}
},
{
"c": "shell",
"t": "source.makefile string.interpolated.makefile meta.scope.function-call.makefile support.function.shell.makefile",
"r": {
"dark_plus": "support.function: #DCDCAA",
"light_plus": "support.function: #795E26",
"dark_vs": "string: #CE9178",
"light_vs": "string: #A31515",
"hc_black": "support.function: #DCDCAA"
}
},
{
"c": " echo \"from inlined shell\"",
"t": "source.makefile string.interpolated.makefile meta.scope.function-call.makefile",
"r": {
"dark_plus": "string: #CE9178",
"light_plus": "string: #A31515",
"dark_vs": "string: #CE9178",
"light_vs": "string: #A31515",
"hc_black": "string: #CE9178"
}
},
{
"c": ")",
"t": "source.makefile string.interpolated.makefile punctuation.definition.variable.makefile",
"r": {
"dark_plus": "string: #CE9178",
"light_plus": "string: #A31515",
"dark_vs": "string: #CE9178",
"light_vs": "string: #A31515",
"hc_black": "string: #CE9178"
}
},
{
"c": "\"",
"t": "source.makefile",
"r": {
"dark_plus": "default: #D4D4D4",
"light_plus": "default: #000000",
"dark_vs": "default: #D4D4D4",
"light_vs": "default: #000000",
"hc_black": "default: #FFFFFF"
}
},
{
"c": "$(",
"t": "source.makefile string.interpolated.makefile punctuation.definition.variable.makefile",
"r": {
"dark_plus": "string: #CE9178",
"light_plus": "string: #A31515",
"dark_vs": "string: #CE9178",
"light_vs": "string: #A31515",
"hc_black": "string: #CE9178"
}
},
{
"c": "info",
"t": "source.makefile string.interpolated.makefile meta.scope.function-call.makefile support.function.info.makefile",
"r": {
"dark_plus": "support.function: #DCDCAA",
"light_plus": "support.function: #795E26",
"dark_vs": "string: #CE9178",
"light_vs": "string: #A31515",
"hc_black": "support.function: #DCDCAA"
}
},
{
"c": " ",
"t": "source.makefile string.interpolated.makefile meta.scope.function-call.makefile",
"r": {
"dark_plus": "string: #CE9178",
"light_plus": "string: #A31515",
"dark_vs": "string: #CE9178",
"light_vs": "string: #A31515",
"hc_black": "string: #CE9178"
}
},
{
"c": "$(",
"t": "source.makefile string.interpolated.makefile meta.scope.function-call.makefile string.interpolated.makefile punctuation.definition.variable.makefile",
"r": {
"dark_plus": "string: #CE9178",
"light_plus": "string: #A31515",
"dark_vs": "string: #CE9178",
"light_vs": "string: #A31515",
"hc_black": "string: #CE9178"
}
},
{
"c": "result",
"t": "source.makefile string.interpolated.makefile meta.scope.function-call.makefile string.interpolated.makefile variable.other.makefile",
"r": {
"dark_plus": "variable: #9CDCFE",
"light_plus": "variable: #001080",
"dark_vs": "string: #CE9178",
"light_vs": "string: #A31515",
"hc_black": "variable: #9CDCFE"
}
},
{
"c": ")",
"t": "source.makefile string.interpolated.makefile meta.scope.function-call.makefile string.interpolated.makefile punctuation.definition.variable.makefile",
"r": {
"dark_plus": "string: #CE9178",
"light_plus": "string: #A31515",
"dark_vs": "string: #CE9178",
"light_vs": "string: #A31515",
"hc_black": "string: #CE9178"
}
},
{
"c": ")",
"t": "source.makefile string.interpolated.makefile punctuation.definition.variable.makefile",
"r": {
"dark_plus": "string: #CE9178",
"light_plus": "string: #A31515",
"dark_vs": "string: #CE9178",
"light_vs": "string: #A31515",
"hc_black": "string: #CE9178"
}
},
{
"c": "#",
"t": "source.makefile comment.line.number-sign.makefile punctuation.definition.comment.makefile",
"r": {
"dark_plus": "comment: #6A9955",
"light_plus": "comment: #008000",
"dark_vs": "comment: #6A9955",
"light_vs": "comment: #008000",
"hc_black": "comment: #7CA668"
}
},
{
"c": " Below is a test of variable assignment without any spacing.",
"t": "source.makefile comment.line.number-sign.makefile",
"r": {
"dark_plus": "comment: #6A9955",
"light_plus": "comment: #008000",
"dark_vs": "comment: #6A9955",
"light_vs": "comment: #008000",
"hc_black": "comment: #7CA668"
}
},
{
"c": "var",
"t": "source.makefile variable.other.makefile",
"r": {
"dark_plus": "variable: #9CDCFE",
"light_plus": "variable: #001080",
"dark_vs": "default: #D4D4D4",
"light_vs": "default: #000000",
"hc_black": "variable: #9CDCFE"
}
},
{
"c": "=",
"t": "source.makefile punctuation.separator.key-value.makefile",
"r": {
"dark_plus": "default: #D4D4D4",
"light_plus": "default: #000000",
"dark_vs": "default: #D4D4D4",
"light_vs": "default: #000000",
"hc_black": "default: #FFFFFF"
}
},
{
"c": "val",
"t": "source.makefile",
"r": {
"dark_plus": "default: #D4D4D4",
"light_plus": "default: #000000",
"dark_vs": "default: #D4D4D4",
"light_vs": "default: #000000",
"hc_black": "default: #FFFFFF"
}
},
{
"c": "var",
"t": "source.makefile variable.other.makefile",
"r": {
"dark_plus": "variable: #9CDCFE",
"light_plus": "variable: #001080",
"dark_vs": "default: #D4D4D4",
"light_vs": "default: #000000",
"hc_black": "variable: #9CDCFE"
}
},
{
"c": "?=",
"t": "source.makefile punctuation.separator.key-value.makefile",
"r": {
"dark_plus": "default: #D4D4D4",
"light_plus": "default: #000000",
"dark_vs": "default: #D4D4D4",
"light_vs": "default: #000000",
"hc_black": "default: #FFFFFF"
}
},
{
"c": "val",
"t": "source.makefile",
"r": {
"dark_plus": "default: #D4D4D4",
"light_plus": "default: #000000",
"dark_vs": "default: #D4D4D4",
"light_vs": "default: #000000",
"hc_black": "default: #FFFFFF"
}
},
{
"c": "var",
"t": "source.makefile variable.other.makefile",
"r": {
"dark_plus": "variable: #9CDCFE",
"light_plus": "variable: #001080",
"dark_vs": "default: #D4D4D4",
"light_vs": "default: #000000",
"hc_black": "variable: #9CDCFE"
}
},
{
"c": ":=",
"t": "source.makefile punctuation.separator.key-value.makefile",
"r": {
"dark_plus": "default: #D4D4D4",
"light_plus": "default: #000000",
"dark_vs": "default: #D4D4D4",
"light_vs": "default: #000000",
"hc_black": "default: #FFFFFF"
}
},
{
"c": "123",
"t": "source.makefile",
"r": {
"dark_plus": "default: #D4D4D4",
"light_plus": "default: #000000",
"dark_vs": "default: #D4D4D4",
"light_vs": "default: #000000",
"hc_black": "default: #FFFFFF"
}
},
{
"c": "var",
"t": "source.makefile variable.other.makefile",
"r": {
"dark_plus": "variable: #9CDCFE",
"light_plus": "variable: #001080",
"dark_vs": "default: #D4D4D4",
"light_vs": "default: #000000",
"hc_black": "variable: #9CDCFE"
}
},
{
"c": "!=",
"t": "source.makefile punctuation.separator.key-value.makefile",
"r": {
"dark_plus": "default: #D4D4D4",
"light_plus": "default: #000000",
"dark_vs": "default: #D4D4D4",
"light_vs": "default: #000000",
"hc_black": "default: #FFFFFF"
}
},
{
"c": "echo val",
"t": "source.makefile",
"r": {
"dark_plus": "default: #D4D4D4",
"light_plus": "default: #000000",
"dark_vs": "default: #D4D4D4",
"light_vs": "default: #000000",
"hc_black": "default: #FFFFFF"
}
},
{
"c": "var",
"t": "source.makefile variable.other.makefile",
"r": {
"dark_plus": "variable: #9CDCFE",
"light_plus": "variable: #001080",
"dark_vs": "default: #D4D4D4",
"light_vs": "default: #000000",
"hc_black": "variable: #9CDCFE"
}
},
{
"c": ":=",
"t": "source.makefile punctuation.separator.key-value.makefile",
"r": {
"dark_plus": "default: #D4D4D4",
"light_plus": "default: #000000",
"dark_vs": "default: #D4D4D4",
"light_vs": "default: #000000",
"hc_black": "default: #FFFFFF"
}
},
{
"c": "val ",
"t": "source.makefile",
"r": {
"dark_plus": "default: #D4D4D4",
"light_plus": "default: #000000",
"dark_vs": "default: #D4D4D4",
"light_vs": "default: #000000",
"hc_black": "default: #FFFFFF"
}
},
{
"c": "\\",
"t": "source.makefile constant.character.escape.continuation.makefile",
"r": {
"dark_plus": "constant.character.escape: #D7BA7D",
"light_plus": "constant.character.escape: #FF0000",
"dark_vs": "default: #D4D4D4",
"light_vs": "default: #000000",
"hc_black": "constant.character: #569CD6"
}
},
{
"c": "notvar=butval",
"t": "source.makefile",
"r": {
"dark_plus": "default: #D4D4D4",
"light_plus": "default: #000000",
"dark_vs": "default: #D4D4D4",
"light_vs": "default: #000000",
"hc_black": "default: #FFFFFF"
}
}
]

7
extensions/npm/src/main.ts
View file

@ -11,9 +11,11 @@ import { invalidateTasksCache, NpmTaskProvider } from './tasks';
import { invalidateHoverScriptsCache, NpmScriptHoverProvider } from './scriptHover';
import { runSelectedScript } from './commands';
let treeDataProvider: NpmScriptsTreeDataProvider | undefined;
export async function activate(context: vscode.ExtensionContext): Promise<void> {
registerTaskProvider(context);
const treeDataProvider = registerExplorer(context);
treeDataProvider = registerExplorer(context);
registerHoverProvider(context);
configureHttpRequest();
@ -46,6 +48,9 @@ function registerTaskProvider(context: vscode.ExtensionContext): vscode.Disposab
function invalidateScriptCaches() {
invalidateHoverScriptsCache();
invalidateTasksCache();
if (treeDataProvider) {
treeDataProvider.refresh();
}
}
if (vscode.workspace.workspaceFolders) {

4
package.json
View file

@ -1,7 +1,7 @@
{
"name": "code-oss-dev",
"version": "1.30.0",
"distro": "8d717142318180c500f0b8c8e1516c892195776f",
"distro": "3e54b1cdfa3b0bb32253d0e81e2fe2b875b2a92a",
"author": {
"name": "Microsoft Corporation"
},
@ -149,4 +149,4 @@
"windows-mutex": "0.2.1",
"windows-process-tree": "0.2.3"
}
}
}

15
src/tsconfig.strictNullChecks.json
View file

@ -64,6 +64,7 @@
"./vs/base/common/json.ts",
"./vs/base/common/jsonEdit.ts",
"./vs/base/common/jsonFormatter.ts",
"./vs/base/common/paths.ts",
"./vs/base/common/uriIpc.ts",
"./vs/base/node/console.ts",
"./vs/base/node/crypto.ts",
@ -97,6 +98,7 @@
"./vs/base/test/common/json.test.ts",
"./vs/base/test/common/jsonEdit.test.ts",
"./vs/base/test/common/jsonFormatter.test.ts",
"./vs/base/test/common/paths.test.ts",
"./vs/base/test/common/utils.ts",
"./vs/base/test/node/processes/fixtures/fork.ts",
"./vs/base/test/node/processes/fixtures/fork_large.ts",
@ -115,6 +117,7 @@
"./vs/code/electron-main/keyboard.ts",
"./vs/code/electron-main/sharedProcess.ts",
"./vs/code/electron-main/theme.ts",
"./vs/code/node/paths.ts",
"./vs/code/node/shellEnv.ts",
"./vs/code/node/wait.ts",
"./vs/code/node/windowsFinder.ts",
@ -385,6 +388,7 @@
"./vs/nls.mock.ts",
"./vs/platform/actions/common/actions.ts",
"./vs/platform/actions/common/menu.ts",
"./vs/platform/actions/common/menuService.ts",
"./vs/platform/backup/common/backup.ts",
"./vs/platform/broadcast/electron-browser/broadcastService.ts",
"./vs/platform/clipboard/common/clipboardService.ts",
@ -468,7 +472,9 @@
"./vs/platform/request/electron-main/requestService.ts",
"./vs/platform/request/node/request.ts",
"./vs/platform/request/node/requestService.ts",
"./vs/platform/search/common/replace.ts",
"./vs/platform/search/common/search.ts",
"./vs/platform/search/test/common/replace.test.ts",
"./vs/platform/state/common/state.ts",
"./vs/platform/statusbar/common/statusbar.ts",
"./vs/platform/storage/common/storage.ts",
@ -609,7 +615,6 @@
"./vs/workbench/parts/welcome/gettingStarted/electron-browser/gettingStarted.ts",
"./vs/workbench/parts/welcome/page/electron-browser/vs_code_welcome_page.ts",
"./vs/workbench/parts/welcome/walkThrough/node/walkThroughUtils.ts",
"./vs/workbench/services/actions/common/menuService.ts",
"./vs/workbench/services/activity/common/activity.ts",
"./vs/workbench/services/backup/common/backup.ts",
"./vs/workbench/services/commands/common/commandService.ts",
@ -654,10 +659,18 @@
"./vs/workbench/services/part/common/partService.ts",
"./vs/workbench/services/scm/common/scm.ts",
"./vs/workbench/services/scm/common/scmService.ts",
"./vs/workbench/services/search/common/searchHelpers.ts",
"./vs/workbench/services/search/node/fileSearchManager.ts",
"./vs/workbench/services/search/node/legacy/search.ts",
"./vs/workbench/services/search/node/ripgrepSearchProvider.ts",
"./vs/workbench/services/search/node/ripgrepSearchUtils.ts",
"./vs/workbench/services/search/node/ripgrepTextSearchEngine.ts",
"./vs/workbench/services/search/node/search.ts",
"./vs/workbench/services/search/node/searchHistoryService.ts",
"./vs/workbench/services/search/node/searchIpc.ts",
"./vs/workbench/services/search/node/textSearchManager.ts",
"./vs/workbench/services/search/test/node/ripgrepTextSearchEngine.test.ts",
"./vs/workbench/services/search/test/node/textSearchManager.test.ts",
"./vs/workbench/services/textMate/electron-browser/TMGrammars.ts",
"./vs/workbench/services/textMate/electron-browser/TMHelper.ts",
"./vs/workbench/services/textMate/electron-browser/textMateService.ts",

2
src/vs/base/browser/contextmenu.ts
View file

@ -23,7 +23,7 @@ export class ContextSubMenu extends SubmenuAction {
export interface IContextMenuDelegate {
getAnchor(): HTMLElement | { x: number; y: number; width?: number; height?: number; };
getActions(): Thenable<(IAction | ContextSubMenu)[]>;
getActions(): (IAction | ContextSubMenu)[];
getActionItem?(action: IAction): IActionItem;
getActionsContext?(event?: IContextMenuEvent): any;
getKeyBinding?(action: IAction): ResolvedKeybinding;

2
src/vs/base/browser/ui/centered/centeredViewLayout.ts
View file

@ -58,7 +58,7 @@ export class CenteredViewLayout {
private emptyViews: ISplitViewView[] | undefined;
private splitViewDisposables: IDisposable[] = [];
constructor(private container: HTMLElement, private view: IView, public readonly state: CenteredViewState = GOLDEN_RATIO) {
constructor(private container: HTMLElement, private view: IView, public readonly state: CenteredViewState = { leftMarginRatio: GOLDEN_RATIO.leftMarginRatio, rightMarginRatio: GOLDEN_RATIO.rightMarginRatio }) {
this.container.appendChild(this.view.element);
// Make sure to hide the split view overflow like sashes #52892
this.container.style.overflow = 'hidden';

4
src/vs/base/browser/ui/dropdown/dropdown.ts
View file

@ -243,7 +243,7 @@ export class DropdownMenu extends BaseDropdown {
this._contextMenuProvider.showContextMenu({
getAnchor: () => this.element,
getActions: () => Promise.resolve(this.actions),
getActions: () => this.actions,
getActionsContext: () => this.menuOptions ? this.menuOptions.context : null,
getActionItem: action => this.menuOptions && this.menuOptions.actionItemProvider ? this.menuOptions.actionItemProvider(action) : null,
getKeyBinding: action => this.menuOptions && this.menuOptions.getKeyBinding ? this.menuOptions.getKeyBinding(action) : null,
@ -332,4 +332,4 @@ export class DropdownMenuActionItem extends BaseActionItem {
this.dropdownMenu.show();
}
}
}
}

2
src/vs/base/browser/ui/tree/objectTreeModel.ts
View file

@ -3,8 +3,6 @@
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
'use strict';
import { ISpliceable } from 'vs/base/common/sequence';
import { Iterator, ISequence } from 'vs/base/common/iterator';
import { IndexTreeModel } from 'vs/base/browser/ui/tree/indexTreeModel';

2
src/vs/base/common/arrays.ts
View file

@ -24,7 +24,7 @@ export function tail2<T>(arr: T[]): [T[], T] {
return [arr.slice(0, arr.length - 1), arr[arr.length - 1]];
}
export function equals<T>(one: ReadonlyArray<T>, other: ReadonlyArray<T>, itemEquals: (a: T, b: T) => boolean = (a, b) => a === b): boolean {
export function equals<T>(one: ReadonlyArray<T> | undefined, other: ReadonlyArray<T> | undefined, itemEquals: (a: T, b: T) => boolean = (a, b) => a === b): boolean {
if (one === other) {
return true;
}

8
src/vs/base/common/async.ts
View file

@ -268,12 +268,12 @@ export class ThrottledDelayer<T> extends Delayer<TPromise<T>> {
export class Barrier {
private _isOpen: boolean;
private _promise: TPromise<boolean>;
private _promise: Promise<boolean>;
private _completePromise: (v: boolean) => void;
constructor() {
this._isOpen = false;
this._promise = new TPromise<boolean>((c, e) => {
this._promise = new Promise<boolean>((c, e) => {
this._completePromise = c;
});
}
@ -287,7 +287,7 @@ export class Barrier {
this._completePromise(true);
}
wait(): TPromise<boolean> {
wait(): Promise<boolean> {
return this._promise;
}
}
@ -673,7 +673,7 @@ export function nfcall(fn: Function, ...args: any[]): any {
export function ninvoke(thisArg: any, fn: Function, ...args: any[]): TPromise;
export function ninvoke<T>(thisArg: any, fn: Function, ...args: any[]): TPromise<T>;
export function ninvoke(thisArg: any, fn: Function, ...args: any[]): any {
return new TPromise((c, e) => fn.call(thisArg, ...args, (err: any, result: any) => err ? e(err) : c(result)));
return new Promise((resolve, reject) => fn.call(thisArg, ...args, (err: any, result: any) => err ? reject(err) : resolve(result)));
}

21
src/vs/base/common/glob.ts
View file

@ -8,7 +8,6 @@ import * as strings from 'vs/base/common/strings';
import * as paths from 'vs/base/common/paths';
import { LRUCache } from 'vs/base/common/map';
import { CharCode } from 'vs/base/common/charCode';
import { TPromise } from 'vs/base/common/winjs.base';
import { isThenable } from 'vs/base/common/async';
export interface IExpression {
@ -248,7 +247,7 @@ const T5 = /^([\w\.-]+(\/[\w\.-]+)*)\/?$/; // something/else
export type ParsedPattern = (path: string, basename?: string) => boolean;
// The ParsedExpression returns a Promise iff hasSibling returns a Promise.
export type ParsedExpression = (path: string, basename?: string, hasSibling?: (name: string) => boolean | TPromise<boolean>) => string | null | TPromise<string | null> /* the matching pattern */;
export type ParsedExpression = (path: string, basename?: string, hasSibling?: (name: string) => boolean | Promise<boolean>) => string | null | Promise<string | null> /* the matching pattern */;
export interface IGlobOptions {
/**
@ -258,14 +257,14 @@ export interface IGlobOptions {
}
interface ParsedStringPattern {
(path: string, basename: string): string | null | TPromise<string | null> /* the matching pattern */;
(path: string, basename: string): string | null | Promise<string | null> /* the matching pattern */;
basenames?: string[];
patterns?: string[];
allBasenames?: string[];
allPaths?: string[];
}
interface ParsedExpressionPattern {
(path: string, basename: string, name?: string, hasSibling?: (name: string) => boolean | TPromise<boolean>): string | null | TPromise<string | null> /* the matching pattern */;
(path: string, basename: string, name?: string, hasSibling?: (name: string) => boolean | Promise<boolean>): string | null | Promise<string | null> /* the matching pattern */;
requiresSiblings?: boolean;
allBasenames?: string[];
allPaths?: string[];
@ -481,15 +480,15 @@ export function parse(arg1: string | IExpression | IRelativePattern, options: IG
return parsedExpression(<IExpression>arg1, options);
}
export function hasSiblingPromiseFn(siblingsFn?: () => TPromise<string[]>) {
export function hasSiblingPromiseFn(siblingsFn?: () => Promise<string[]>) {
if (!siblingsFn) {
return undefined;
}
let siblings: TPromise<Record<string, true>>;
let siblings: Promise<Record<string, true>>;
return (name: string) => {
if (!siblings) {
siblings = (siblingsFn() || TPromise.as([]))
siblings = (siblingsFn() || Promise.resolve([]))
.then(list => list ? listToMap(list) : {});
}
return siblings.then(map => !!map[name]);
@ -530,9 +529,9 @@ export function isRelativePattern(obj: any): obj is IRelativePattern {
*/
export function parseToAsync(expression: IExpression, options?: IGlobOptions): ParsedExpression {
const parsedExpression = parse(expression, options);
return (path: string, basename?: string, hasSibling?: (name: string) => boolean | TPromise<boolean>): string | null | TPromise<string | null> => {
return (path: string, basename?: string, hasSibling?: (name: string) => boolean | Promise<boolean>): string | null | Promise<string | null> => {
const result = parsedExpression(path, basename, hasSibling);
return result instanceof TPromise ? result : TPromise.as(result);
return isThenable(result) ? result : Promise.resolve(result);
};
}
@ -584,7 +583,7 @@ function parsedExpression(expression: IExpression, options: IGlobOptions): Parse
return resultExpression;
}
const resultExpression: ParsedStringPattern = function (path: string, basename: string, hasSibling?: (name: string) => boolean | TPromise<boolean>) {
const resultExpression: ParsedStringPattern = function (path: string, basename: string, hasSibling?: (name: string) => boolean | Promise<boolean>) {
let name: string | undefined = undefined;
for (let i = 0, n = parsedPatterns.length; i < n; i++) {
@ -639,7 +638,7 @@ function parseExpressionPattern(pattern: string, value: any, options: IGlobOptio
if (value) {
const when = (<SiblingClause>value).when;
if (typeof when === 'string') {
const result: ParsedExpressionPattern = (path: string, basename: string, name: string, hasSibling: (name: string) => boolean | TPromise<boolean>) => {
const result: ParsedExpressionPattern = (path: string, basename: string, name: string, hasSibling: (name: string) => boolean | Promise<boolean>) => {
if (!hasSibling || !parsedPattern(path, basename)) {
return null;
}

5
src/vs/base/common/json.ts
View file

@ -2,11 +2,6 @@
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
'use strict';
export const enum ScanError {
None = 0,

1
src/vs/base/common/jsonEdit.ts
View file

@ -2,7 +2,6 @@
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
'use strict';
import { ParseError, Node, JSONPath, Segment, parseTree, findNodeAtLocation } from './json';
import { Edit, format, isEOL, FormattingOptions } from './jsonFormatter';

1
src/vs/base/common/jsonFormatter.ts
View file

@ -2,7 +2,6 @@
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
'use strict';
import { createScanner, SyntaxKind, ScanError } from './json';

7
src/vs/base/common/paths.ts
View file

@ -72,7 +72,10 @@ function _isNormal(path: string, win: boolean): boolean {
: !_posixBadPath.test(path);
}
export function normalize(path: string, toOSPath?: boolean): string {
export function normalize(path: undefined, toOSPath?: boolean): undefined;
export function normalize(path: null, toOSPath?: boolean): null;
export function normalize(path: string, toOSPath?: boolean): string;
export function normalize(path: string | null | undefined, toOSPath?: boolean): string | null | undefined {
if (path === null || path === void 0) {
return path;
@ -288,7 +291,7 @@ export function isUNC(path: string): boolean {
// Reference: https://en.wikipedia.org/wiki/Filename
const INVALID_FILE_CHARS = isWindows ? /[\\/:\*\?"<>\|]/g : /[\\/]/g;
const WINDOWS_FORBIDDEN_NAMES = /^(con|prn|aux|clock\$|nul|lpt[0-9]|com[0-9])$/i;
export function isValidBasename(name: string): boolean {
export function isValidBasename(name: string | null | undefined): boolean {
if (!name || name.length === 0 || /^\s+$/.test(name)) {
return false; // require a name that is not just whitespace
}

2
src/vs/base/common/strings.ts
View file

@ -78,7 +78,7 @@ export function escapeRegExpCharacters(value: string): string {
* @param haystack string to trim
* @param needle the thing to trim (default is a blank)
*/
export function trim(haystack: string, needle: string = ' '): string | undefined {
export function trim(haystack: string, needle: string = ' '): string {
let trimmed = ltrim(haystack, needle);
return rtrim(trimmed, needle);
}

14
src/vs/base/common/uriIpc.ts
View file

@ -8,9 +8,17 @@ import { URI, UriComponents } from 'vs/base/common/uri';
export interface IURITransformer {
transformIncoming(uri: UriComponents): UriComponents;
transformOutgoing(uri: URI): URI;
transformOutgoing(uri: UriComponents): UriComponents;
}
export const DefaultURITransformer: IURITransformer = {
transformIncoming: (uri: UriComponents) => uri,
transformOutgoing: (uri: URI) => uri,
export const DefaultURITransformer: IURITransformer = new class {
transformIncoming(uri: UriComponents) {
return uri;
}
transformOutgoing(uri: URI): URI;
transformOutgoing(uri: UriComponents): UriComponents;
transformOutgoing(uri: URI | UriComponents): URI | UriComponents {
return uri;
}
};

11
src/vs/base/node/crypto.ts
View file

@ -6,11 +6,10 @@
import * as fs from 'fs';
import * as crypto from 'crypto';
import * as stream from 'stream';
import { TPromise } from 'vs/base/common/winjs.base';
import { once } from 'vs/base/common/functional';
export function checksum(path: string, sha1hash: string): TPromise<void> {
const promise = new TPromise<string | undefined>((c, e) => {
export function checksum(path: string, sha1hash: string): Promise<void> {
const promise = new Promise<string | undefined>((c, e) => {
const input = fs.createReadStream(path);
const hash = crypto.createHash('sha1');
const hashStream = hash as any as stream.PassThrough;
@ -35,9 +34,9 @@ export function checksum(path: string, sha1hash: string): TPromise<void> {
return promise.then(hash => {
if (hash !== sha1hash) {
return TPromise.wrapError<void>(new Error('Hash mismatch'));
return Promise.reject(new Error('Hash mismatch'));
}
return TPromise.as(void 0);
return Promise.resolve();
});
}
}

43
src/vs/base/node/processes.ts
View file

@ -7,7 +7,6 @@ import * as path from 'path';
import * as fs from 'fs';
import * as cp from 'child_process';
import * as nls from 'vs/nls';
import { TPromise, TValueCallback, ErrorCallback } from 'vs/base/common/winjs.base';
import * as Types from 'vs/base/common/types';
import { IStringDictionary } from 'vs/base/common/collections';
import * as Objects from 'vs/base/common/objects';
@ -18,7 +17,9 @@ import { CommandOptions, ForkOptions, SuccessData, Source, TerminateResponse, Te
import { getPathFromAmdModule } from 'vs/base/common/amd';
export { CommandOptions, ForkOptions, SuccessData, Source, TerminateResponse, TerminateResponseCode };
export type TProgressCallback<T> = (progress: T) => void;
export type ValueCallback<T> = (value?: T | Thenable<T>) => void;
export type ErrorCallback = (error?: any) => void;
export type ProgressCallback<T> = (progress: T) => void;
export interface LineData {
line: string;
@ -78,8 +79,8 @@ export abstract class AbstractProcess<TProgressData> {
protected shell: boolean;
private childProcess: cp.ChildProcess | null;
protected childProcessPromise: TPromise<cp.ChildProcess> | null;
private pidResolve?: TValueCallback<number>;
protected childProcessPromise: Promise<cp.ChildProcess> | null;
private pidResolve?: ValueCallback<number>;
protected terminateRequested: boolean;
private static WellKnowCommands: IStringDictionary<boolean> = {
@ -146,14 +147,14 @@ export abstract class AbstractProcess<TProgressData> {
return 'other';
}
public start(pp: TProgressCallback<TProgressData>): TPromise<SuccessData> {
public start(pp: ProgressCallback<TProgressData>): Promise<SuccessData> {
if (Platform.isWindows && ((this.options && this.options.cwd && TPath.isUNC(this.options.cwd)) || !this.options && TPath.isUNC(process.cwd()))) {
return TPromise.wrapError(new Error(nls.localize('TaskRunner.UNC', 'Can\'t execute a shell command on a UNC drive.')));
return Promise.reject(new Error(nls.localize('TaskRunner.UNC', 'Can\'t execute a shell command on a UNC drive.')));
}
return this.useExec().then((useExec) => {
let cc: TValueCallback<SuccessData>;
let cc: ValueCallback<SuccessData>;
let ee: ErrorCallback;
let result = new TPromise<any>((c, e) => {
let result = new Promise<any>((c, e) => {
cc = c;
ee = e;
});
@ -229,7 +230,7 @@ export abstract class AbstractProcess<TProgressData> {
}
if (childProcess) {
this.childProcess = childProcess;
this.childProcessPromise = TPromise.as(childProcess);
this.childProcessPromise = Promise.resolve(childProcess);
if (this.pidResolve) {
this.pidResolve(Types.isNumber(childProcess.pid) ? childProcess.pid : -1);
this.pidResolve = undefined;
@ -248,10 +249,10 @@ export abstract class AbstractProcess<TProgressData> {
});
}
protected abstract handleExec(cc: TValueCallback<SuccessData>, pp: TProgressCallback<TProgressData>, error: Error | null, stdout: Buffer, stderr: Buffer): void;
protected abstract handleSpawn(childProcess: cp.ChildProcess, cc: TValueCallback<SuccessData>, pp: TProgressCallback<TProgressData>, ee: ErrorCallback, sync: boolean): void;
protected abstract handleExec(cc: ValueCallback<SuccessData>, pp: ProgressCallback<TProgressData>, error: Error | null, stdout: Buffer, stderr: Buffer): void;
protected abstract handleSpawn(childProcess: cp.ChildProcess, cc: ValueCallback<SuccessData>, pp: ProgressCallback<TProgressData>, ee: ErrorCallback, sync: boolean): void;
protected handleClose(data: any, cc: TValueCallback<SuccessData>, pp: TProgressCallback<TProgressData>, ee: ErrorCallback): void {
protected handleClose(data: any, cc: ValueCallback<SuccessData>, pp: ProgressCallback<TProgressData>, ee: ErrorCallback): void {
// Default is to do nothing.
}
@ -270,19 +271,19 @@ export abstract class AbstractProcess<TProgressData> {
}
}
public get pid(): TPromise<number> {
public get pid(): Promise<number> {
if (this.childProcessPromise) {
return this.childProcessPromise.then(childProcess => childProcess.pid, err => -1);
} else {
return new TPromise<number>((resolve) => {
return new Promise<number>((resolve) => {
this.pidResolve = resolve;
});
}
}
public terminate(): TPromise<TerminateResponse> {
public terminate(): Promise<TerminateResponse> {
if (!this.childProcessPromise) {
return TPromise.as<TerminateResponse>({ success: true });
return Promise.resolve<TerminateResponse>({ success: true });
}
return this.childProcessPromise.then((childProcess) => {
this.terminateRequested = true;
@ -296,8 +297,8 @@ export abstract class AbstractProcess<TProgressData> {
});
}
private useExec(): TPromise<boolean> {
return new TPromise<boolean>((c, e) => {
private useExec(): Promise<boolean> {
return new Promise<boolean>((c, e) => {
if (!this.shell || !Platform.isWindows) {
c(false);
}
@ -323,7 +324,7 @@ export class LineProcess extends AbstractProcess<LineData> {
super(<any>arg1, arg2, <any>arg3, arg4);
}
protected handleExec(cc: TValueCallback<SuccessData>, pp: TProgressCallback<LineData>, error: Error, stdout: Buffer, stderr: Buffer) {
protected handleExec(cc: ValueCallback<SuccessData>, pp: ProgressCallback<LineData>, error: Error, stdout: Buffer, stderr: Buffer) {
[stdout, stderr].forEach((buffer: Buffer, index: number) => {
let lineDecoder = new LineDecoder();
let lines = lineDecoder.write(buffer);
@ -338,7 +339,7 @@ export class LineProcess extends AbstractProcess<LineData> {
cc({ terminated: this.terminateRequested, error: error });
}
protected handleSpawn(childProcess: cp.ChildProcess, cc: TValueCallback<SuccessData>, pp: TProgressCallback<LineData>, ee: ErrorCallback, sync: boolean): void {
protected handleSpawn(childProcess: cp.ChildProcess, cc: ValueCallback<SuccessData>, pp: ProgressCallback<LineData>, ee: ErrorCallback, sync: boolean): void {
this.stdoutLineDecoder = new LineDecoder();
this.stderrLineDecoder = new LineDecoder();
childProcess.stdout.on('data', (data: Buffer) => {
@ -351,7 +352,7 @@ export class LineProcess extends AbstractProcess<LineData> {
});
}
protected handleClose(data: any, cc: TValueCallback<SuccessData>, pp: TProgressCallback<LineData>, ee: ErrorCallback): void {
protected handleClose(data: any, cc: ValueCallback<SuccessData>, pp: ProgressCallback<LineData>, ee: ErrorCallback): void {
[this.stdoutLineDecoder.end(), this.stderrLineDecoder.end()].forEach((line, index) => {
if (line) {
pp({ line: line, source: index === 0 ? Source.stdout : Source.stderr });

24
src/vs/base/parts/quickopen/browser/quickOpenModel.ts
View file

@ -4,7 +4,6 @@
*--------------------------------------------------------------------------------------------*/
import * as nls from 'vs/nls';
import { TPromise } from 'vs/base/common/winjs.base';
import * as types from 'vs/base/common/types';
import { URI } from 'vs/base/common/uri';
import { ITree, IActionProvider } from 'vs/base/parts/tree/browser/tree';
@ -289,16 +288,16 @@ class NoActionProvider implements IActionProvider {
return false;
}
getActions(tree: ITree, element: any): TPromise<IAction[]> {
return TPromise.as(null);
getActions(tree: ITree, element: any): IAction[] {
return null;
}
hasSecondaryActions(tree: ITree, element: any): boolean {
return false;
}
getSecondaryActions(tree: ITree, element: any): TPromise<IAction[]> {
return TPromise.as(null);
getSecondaryActions(tree: ITree, element: any): IAction[] {
return null;
}
getActionItem(tree: ITree, element: any, action: Action): IActionItem {
@ -421,13 +420,12 @@ class Renderer implements IRenderer<QuickOpenEntry> {
data.actionBar.context = entry; // make sure the context is the current element
this.actionProvider.getActions(null, entry).then((actions) => {
if (data.actionBar.isEmpty() && actions && actions.length > 0) {
data.actionBar.push(actions, { icon: true, label: false });
} else if (!data.actionBar.isEmpty() && (!actions || actions.length === 0)) {
data.actionBar.clear();
}
});
const actions = this.actionProvider.getActions(null, entry);
if (data.actionBar.isEmpty() && actions && actions.length > 0) {
data.actionBar.push(actions, { icon: true, label: false });
} else if (!data.actionBar.isEmpty() && (!actions || actions.length === 0)) {
data.actionBar.clear();
}
// Entry group class
if (entry instanceof QuickOpenEntryGroup && entry.getGroupLabel()) {
@ -620,4 +618,4 @@ export function compareEntries(elementA: QuickOpenEntry, elementB: QuickOpenEntr
}
return compareAnything(nameA, nameB, lookFor);
}
}

4
src/vs/base/parts/tree/browser/tree.ts
View file

@ -731,7 +731,7 @@ export interface IActionProvider {
/**
* Returns a promise of an array with the actions of the element that should show up in place right to the element in the tree.
*/
getActions(tree: ITree, element: any): WinJS.TPromise<IAction[]>;
getActions(tree: ITree, element: any): IAction[];
/**
* Returns whether or not the element has secondary actions. These show up once the user has expanded the element's action bar.
@ -741,7 +741,7 @@ export interface IActionProvider {
/**
* Returns a promise of an array with the secondary actions of the element that should show up once the user has expanded the element's action bar.
*/
getSecondaryActions(tree: ITree, element: any): WinJS.TPromise<IAction[]>;
getSecondaryActions(tree: ITree, element: any): IAction[];
/**
* Returns an action item to render an action.

35
src/vs/base/test/common/utils.ts
View file

@ -5,33 +5,46 @@
import * as paths from 'vs/base/common/paths';
import { URI } from 'vs/base/common/uri';
import { TPromise, TValueCallback } from 'vs/base/common/winjs.base';
import { canceled } from 'vs/base/common/errors';
export class DeferredTPromise<T> extends TPromise<T> {
export type ValueCallback<T = any> = (value: T | Thenable<T>) => void;
private completeCallback: TValueCallback<T>;
export class DeferredPromise<T> {
private completeCallback: ValueCallback<T>;
private errorCallback: (err: any) => void;
public p: Promise<any>;
constructor() {
let captured: any;
super((c, e) => {
captured = { c, e };
this.p = new Promise<any>((c, e) => {
this.completeCallback = c;
this.errorCallback = e;
});
this.completeCallback = captured.c;
this.errorCallback = captured.e;
}
public complete(value: T) {
this.completeCallback(value);
return new Promise(resolve => {
process.nextTick(() => {
this.completeCallback(value);
resolve();
});
});
}
public error(err: any) {
this.errorCallback(err);
return new Promise(resolve => {
process.nextTick(() => {
this.errorCallback(err);
resolve();
});
});
}
public cancel() {
this.errorCallback(canceled());
process.nextTick(() => {
this.errorCallback(canceled());
});
}
}

7
src/vs/base/test/node/pfs.test.ts
View file

@ -2,7 +2,6 @@
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { TPromise } from 'vs/base/common/winjs.base';
import * as assert from 'assert';
import * as os from 'os';
@ -46,7 +45,7 @@ suite('PFS', () => {
return pfs.mkdirp(newDir, 493).then(() => {
assert.ok(fs.existsSync(newDir));
return TPromise.join([
return Promise.all([
pfs.writeFile(testFile1, 'Hello World 1', null),
pfs.writeFile(testFile2, 'Hello World 2', null),
pfs.writeFile(testFile3, 'Hello World 3', null),
@ -73,7 +72,7 @@ suite('PFS', () => {
return pfs.mkdirp(newDir, 493).then(() => {
assert.ok(fs.existsSync(newDir));
return TPromise.join([
return Promise.all([
pfs.writeFile(testFile, 'Hello World 1', null),
pfs.writeFile(testFile, 'Hello World 2', null),
timeout(10).then(() => pfs.writeFile(testFile, 'Hello World 3', null)),
@ -119,4 +118,4 @@ suite('PFS', () => {
});
});
});
});
});

7
src/vs/base/test/node/utils.ts
View file

@ -3,7 +3,6 @@
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { TPromise } from 'vs/base/common/winjs.base';
import { generateUuid } from 'vs/base/common/uuid';
import { join } from 'path';
import { tmpdir } from 'os';
@ -11,10 +10,10 @@ import { mkdirp, del } from 'vs/base/node/pfs';
export interface ITestFileResult {
testFile: string;
cleanUp: () => TPromise<void>;
cleanUp: () => Thenable<void>;
}
export function testFile(folder: string, file: string): TPromise<ITestFileResult> {
export function testFile(folder: string, file: string): Thenable<ITestFileResult> {
const id = generateUuid();
const parentDir = join(tmpdir(), 'vsctests', id);
const newDir = join(parentDir, 'config', id);
@ -26,4 +25,4 @@ export function testFile(folder: string, file: string): TPromise<ITestFileResult
cleanUp: () => del(parentDir, tmpdir())
} as ITestFileResult;
});
}
}

1
src/vs/base/worker/workerMain.ts
View file

@ -4,7 +4,6 @@
*--------------------------------------------------------------------------------------------*/
(function () {
'use strict';
let MonacoEnvironment = (<any>self).MonacoEnvironment;
let monacoBaseUrl = MonacoEnvironment && MonacoEnvironment.baseUrl ? MonacoEnvironment.baseUrl : '../../../';

2
src/vs/code/electron-main/main.ts
View file

@ -57,7 +57,7 @@ function createServices(args: ParsedArgs, bufferLogService: BufferLogService): I
const environmentService = new EnvironmentService(args, process.execPath);
const consoleLogService = new ConsoleLogMainService(getLogLevel(environmentService));
const logService = new MultiplexLogService([consoleLogService, bufferLogService]);
const labelService = new LabelService(environmentService, undefined);
const labelService = new LabelService(environmentService, undefined, undefined);
process.once('exit', () => logService.dispose());

4
src/vs/code/electron-main/window.ts
View file

@ -284,6 +284,10 @@ export class CodeWindow implements ICodeWindow {
return this.currentConfig ? this.currentConfig.folderUri : void 0;
}
get remoteAuthority(): string {
return this.currentConfig ? this.currentConfig.remoteAuthority : void 0;
}
setReady(): void {
this._readyState = ReadyState.READY;

89
src/vs/code/electron-main/windows.ts
View file

@ -37,6 +37,7 @@ import { Queue, timeout } from 'vs/base/common/async';
import { exists } from 'vs/base/node/pfs';
import { getComparisonKey, isEqual, normalizePath } from 'vs/base/common/resources';
import { endsWith } from 'vs/base/common/strings';
import { getRemoteAuthority } from 'vs/platform/remote/common/remoteHosts';
enum WindowError {
UNRESPONSIVE,
@ -51,6 +52,7 @@ interface IWindowState {
workspace?: IWorkspaceIdentifier;
folderUri?: URI;
backupPath: string;
remoteAuthority?: string;
uiState: ISingleWindowState;
}
@ -73,6 +75,8 @@ interface IOpenBrowserWindowOptions {
workspace?: IWorkspaceIdentifier;
folderUri?: URI;
remoteAuthority: string;
initialStartup?: boolean;
fileInputs?: IFileInputs;
@ -88,6 +92,7 @@ interface IPathParseOptions {
ignoreFileNotFound?: boolean;
gotoLineMode?: boolean;
forceOpenWorkspaceAsFile?: boolean;
remoteAuthority?: string;
}
interface IFileInputs {
@ -95,6 +100,7 @@ interface IFileInputs {
filesToCreate: IPath[];
filesToDiff: IPath[];
filesToWait?: IPathsToWaitFor;
remoteAuthority?: string;
}
interface IPathToOpen extends IPath {
@ -108,6 +114,9 @@ interface IPathToOpen extends IPath {
// the backup path for a Code instance to use
backupPath?: string;
// the remote authority for the Code instance to open. Undefined if not remote.
remoteAuthority?: string;
// indicator to create the file path in the Code instance
createFilePath?: boolean;
}
@ -358,6 +367,7 @@ export class WindowsManager implements IWindowsMainService {
workspace: win.openedWorkspace,
folderUri: win.openedFolderUri,
backupPath: win.backupPath,
remoteAuthority: win.remoteAuthority,
uiState: win.serializeWindowState()
};
}
@ -381,7 +391,7 @@ export class WindowsManager implements IWindowsMainService {
for (const path of pathsToOpen) {
if (path.fileUri) {
if (!fileInputs) {
fileInputs = { filesToCreate: [], filesToOpen: [], filesToDiff: [] };
fileInputs = { filesToCreate: [], filesToOpen: [], filesToDiff: [], remoteAuthority: path.remoteAuthority };
}
if (!path.createFilePath) {
fileInputs.filesToOpen.push(path);
@ -427,7 +437,7 @@ export class WindowsManager implements IWindowsMainService {
workspacesToRestore.push(...this.workspacesMainService.getUntitledWorkspacesSync()); // collect from previous window session
emptyToRestore = this.backupMainService.getEmptyWindowBackupPaths();
emptyToRestore.push(...pathsToOpen.filter(w => !w.workspace && !w.folderUri && w.backupPath).map(w => ({ backupFolder: basename(w.backupPath) }))); // add empty windows with backupPath
emptyToRestore.push(...pathsToOpen.filter(w => !w.workspace && !w.folderUri && w.backupPath).map(w => ({ backupFolder: basename(w.backupPath), remoteAuthority: w.remoteAuthority }))); // add empty windows with backupPath
emptyToRestore = arrays.distinct(emptyToRestore, info => info.backupFolder); // prevent duplicates
}
@ -537,7 +547,8 @@ export class WindowsManager implements IWindowsMainService {
// Handle folders to add by looking for the last active workspace (not on initial startup)
if (!openConfig.initialStartup && foldersToAdd.length > 0) {
const lastActiveWindow = this.getLastActiveWindow();
const authority = getRemoteAuthority(foldersToAdd[0]);
const lastActiveWindow = this.getLastActiveWindowForAuthority(authority);
if (lastActiveWindow) {
usedWindows.push(this.doAddFoldersToExistingWindow(lastActiveWindow, foldersToAdd));
}
@ -552,7 +563,8 @@ export class WindowsManager implements IWindowsMainService {
// Find suitable window or folder path to open files in
const fileToCheck = fileInputs.filesToOpen[0] || fileInputs.filesToCreate[0] || fileInputs.filesToDiff[0];
const windows = WindowsManager.WINDOWS;
// only look at the windows with correct authority
const windows = WindowsManager.WINDOWS.filter(w => w.remoteAuthority === fileInputs.remoteAuthority);
let bestWindowOrFolder = findBestWindowOrFolderForFile({
windows,
@ -595,6 +607,7 @@ export class WindowsManager implements IWindowsMainService {
initialStartup: openConfig.initialStartup,
fileInputs,
forceNewWindow: true,
remoteAuthority: fileInputs.remoteAuthority,
forceNewTabbedWindow: openConfig.forceNewTabbedWindow
}));
@ -611,7 +624,7 @@ export class WindowsManager implements IWindowsMainService {
const windowsOnWorkspace = arrays.coalesce(allWorkspacesToOpen.map(workspaceToOpen => findWindowOnWorkspace(WindowsManager.WINDOWS, workspaceToOpen)));
if (windowsOnWorkspace.length > 0) {
const windowOnWorkspace = windowsOnWorkspace[0];
const fileInputsForWindow = fileInputs;
const fileInputsForWindow = (fileInputs && fileInputs.remoteAuthority === windowOnWorkspace.remoteAuthority) ? fileInputs : void 0;
// Do open files
usedWindows.push(this.doOpenFilesInExistingWindow(openConfig, windowOnWorkspace, fileInputsForWindow));
@ -630,7 +643,7 @@ export class WindowsManager implements IWindowsMainService {
return; // ignore folders that are already open
}
const fileInputsForWindow = fileInputs;
const fileInputsForWindow = (fileInputs && !fileInputs.remoteAuthority) ? fileInputs : void 0;
// Do open folder
usedWindows.push(this.doOpenFolderOrWorkspace(openConfig, { workspace: workspaceToOpen }, openFolderInNewWindow, fileInputsForWindow));
@ -653,7 +666,7 @@ export class WindowsManager implements IWindowsMainService {
const windowsOnFolderPath = arrays.coalesce(allFoldersToOpen.map(folderToOpen => findWindowOnWorkspace(WindowsManager.WINDOWS, folderToOpen)));
if (windowsOnFolderPath.length > 0) {
const windowOnFolderPath = windowsOnFolderPath[0];
const fileInputsForWindow = fileInputs;
const fileInputsForWindow = fileInputs && fileInputs.remoteAuthority === windowOnFolderPath.remoteAuthority ? fileInputs : void 0;
// Do open files
usedWindows.push(this.doOpenFilesInExistingWindow(openConfig, windowOnFolderPath, fileInputsForWindow));
@ -673,10 +686,11 @@ export class WindowsManager implements IWindowsMainService {
return; // ignore folders that are already open
}
const fileInputsForWindow = fileInputs;
const remoteAuthority = getRemoteAuthority(folderToOpen);
const fileInputsForWindow = (fileInputs && fileInputs.remoteAuthority === remoteAuthority) ? fileInputs : void 0;
// Do open folder
usedWindows.push(this.doOpenFolderOrWorkspace(openConfig, { folderUri: folderToOpen }, openFolderInNewWindow, fileInputsForWindow));
usedWindows.push(this.doOpenFolderOrWorkspace(openConfig, { folderUri: folderToOpen, remoteAuthority }, openFolderInNewWindow, fileInputsForWindow));
// Reset these because we handled them
if (fileInputsForWindow) {
@ -690,13 +704,15 @@ export class WindowsManager implements IWindowsMainService {
// Handle empty to restore
if (emptyToRestore.length > 0) {
emptyToRestore.forEach(emptyWindowBackupInfo => {
const fileInputsForWindow = fileInputs;
const remoteAuthority = emptyWindowBackupInfo.remoteAuthority;
const fileInputsForWindow = (fileInputs && fileInputs.remoteAuthority === remoteAuthority) ? fileInputs : void 0;
usedWindows.push(this.openInBrowserWindow({
userEnv: openConfig.userEnv,
cli: openConfig.cli,
initialStartup: openConfig.initialStartup,
fileInputs: fileInputsForWindow,
remoteAuthority,
forceNewWindow: true,
forceNewTabbedWindow: openConfig.forceNewTabbedWindow,
emptyWindowBackupInfo
@ -716,11 +732,13 @@ export class WindowsManager implements IWindowsMainService {
if (fileInputs && !emptyToOpen) {
emptyToOpen++;
}
const remoteAuthority = fileInputs ? fileInputs.remoteAuthority : (openConfig.cli && openConfig.cli.remote || void 0);
for (let i = 0; i < emptyToOpen; i++) {
usedWindows.push(this.openInBrowserWindow({
userEnv: openConfig.userEnv,
cli: openConfig.cli,
initialStartup: openConfig.initialStartup,
remoteAuthority,
forceNewWindow: openFolderInNewWindow,
forceNewTabbedWindow: openConfig.forceNewTabbedWindow,
fileInputs
@ -777,6 +795,7 @@ export class WindowsManager implements IWindowsMainService {
workspace: folderOrWorkspace.workspace,
folderUri: folderOrWorkspace.folderUri,
fileInputs,
remoteAuthority: folderOrWorkspace.remoteAuthority,
forceNewWindow,
forceNewTabbedWindow: openConfig.forceNewTabbedWindow,
windowToUse
@ -821,7 +840,7 @@ export class WindowsManager implements IWindowsMainService {
const workspace = this.workspacesMainService.createWorkspaceSync(foldersToOpen.map(folder => ({ uri: folder.folderUri })));
// Add workspace and remove folders thereby
windowsToOpen.push({ workspace });
windowsToOpen.push({ workspace, remoteAuthority: foldersToOpen[0].remoteAuthority });
windowsToOpen = windowsToOpen.filter(path => !path.folderUri);
}
}
@ -869,7 +888,7 @@ export class WindowsManager implements IWindowsMainService {
private doExtractPathsFromCLI(cli: ParsedArgs): IPath[] {
const pathsToOpen: IPathToOpen[] = [];
const parseOptions: IPathParseOptions = { ignoreFileNotFound: true, gotoLineMode: cli.goto };
const parseOptions: IPathParseOptions = { ignoreFileNotFound: true, gotoLineMode: cli.goto, remoteAuthority: cli.remote || void 0 };
// folder uris
const folderUris = asArray(cli['folder-uri']);
@ -932,17 +951,17 @@ export class WindowsManager implements IWindowsMainService {
const windowsToOpen: IPathToOpen[] = [];
for (const openedWindow of openedWindows) {
if (openedWindow.workspace) { // Workspaces
const pathToOpen = this.parsePath(openedWindow.workspace.configPath);
const pathToOpen = this.parsePath(openedWindow.workspace.configPath, { remoteAuthority: openedWindow.remoteAuthority });
if (pathToOpen && pathToOpen.workspace) {
windowsToOpen.push(pathToOpen);
}
} else if (openedWindow.folderUri) { // Folders
const pathToOpen = this.parseUri(openedWindow.folderUri, false);
const pathToOpen = this.parseUri(openedWindow.folderUri, false, { remoteAuthority: openedWindow.remoteAuthority });
if (pathToOpen && pathToOpen.folderUri) {
windowsToOpen.push(pathToOpen);
}
} else if (restoreWindows !== 'folders' && openedWindow.backupPath) { // Windows that were Empty
windowsToOpen.push({ backupPath: openedWindow.backupPath });
windowsToOpen.push({ backupPath: openedWindow.backupPath, remoteAuthority: openedWindow.remoteAuthority });
}
}
@ -994,6 +1013,10 @@ export class WindowsManager implements IWindowsMainService {
if (uri.scheme === Schemas.file) {
return this.parsePath(uri.fsPath, options);
}
// open remote if either specified in the cli or if it's a remotehost URI
const remoteAuthority = options && options.remoteAuthority || getRemoteAuthority(uri);
// normalize URI
uri = normalizePath(uri);
if (endsWith(uri.path, '/')) {
@ -1005,15 +1028,18 @@ export class WindowsManager implements IWindowsMainService {
return {
fileUri: uri.with({ path: parsedPath.path }),
lineNumber: parsedPath.line,
columnNumber: parsedPath.column
columnNumber: parsedPath.column,
remoteAuthority
};
}
return {
fileUri: uri
fileUri: uri,
remoteAuthority
};
}
return {
folderUri: uri
folderUri: uri,
remoteAuthority
};
}
@ -1030,6 +1056,9 @@ export class WindowsManager implements IWindowsMainService {
anyPath = parsedPath.path;
}
// open remote if either specified in the cli even if it is a local file. TODO: Future idea: resolve in remote host context.
const remoteAuthority = options && options.remoteAuthority;
const candidate = normalize(anyPath);
try {
const candidateStat = fs.statSync(candidate);
@ -1040,7 +1069,7 @@ export class WindowsManager implements IWindowsMainService {
if (!options || !options.forceOpenWorkspaceAsFile) {
const workspace = this.workspacesMainService.resolveWorkspaceSync(candidate);
if (workspace) {
return { workspace: { id: workspace.id, configPath: workspace.configPath } };
return { workspace: { id: workspace.id, configPath: workspace.configPath }, remoteAuthority };
}
}
@ -1048,7 +1077,8 @@ export class WindowsManager implements IWindowsMainService {
return {
fileUri: URI.file(candidate),
lineNumber: gotoLineMode ? parsedPath.line : void 0,
columnNumber: gotoLineMode ? parsedPath.column : void 0
columnNumber: gotoLineMode ? parsedPath.column : void 0,
remoteAuthority
};
}
@ -1057,7 +1087,8 @@ export class WindowsManager implements IWindowsMainService {
// over to us)
else if (candidateStat.isDirectory()) {
return {
folderUri: URI.file(candidate)
folderUri: URI.file(candidate),
remoteAuthority
};
}
}
@ -1066,7 +1097,7 @@ export class WindowsManager implements IWindowsMainService {
this.historyMainService.removeFromRecentlyOpened([fileUri]); // since file does not seem to exist anymore, remove from recent
if (options && options.ignoreFileNotFound) {
return { fileUri, createFilePath: true }; // assume this is a file that does not yet exist
return { fileUri, createFilePath: true, remoteAuthority }; // assume this is a file that does not yet exist
}
}
@ -1181,6 +1212,7 @@ export class WindowsManager implements IWindowsMainService {
configuration.isInitialStartup = options.initialStartup;
configuration.workspace = options.workspace;
configuration.folderUri = options.folderUri;
configuration.remoteAuthority = options.remoteAuthority;
const fileInputs = options.fileInputs;
if (fileInputs) {
@ -1286,7 +1318,7 @@ export class WindowsManager implements IWindowsMainService {
configuration.backupPath = this.backupMainService.registerFolderBackupSync(configuration.folderUri);
} else {
const backupFolder = options.emptyWindowBackupInfo && options.emptyWindowBackupInfo.backupFolder;
configuration.backupPath = this.backupMainService.registerEmptyWindowBackupSync({ backupFolder });
configuration.backupPath = this.backupMainService.registerEmptyWindowBackupSync({ backupFolder, remoteAuthority: configuration.remoteAuthority });
}
}
@ -1444,7 +1476,8 @@ export class WindowsManager implements IWindowsMainService {
closeWorkspace(win: ICodeWindow): void {
this.openInBrowserWindow({
cli: this.environmentService.args,
windowToUse: win
windowToUse: win,
remoteAuthority: win.remoteAuthority
});
}
@ -1528,8 +1561,16 @@ export class WindowsManager implements IWindowsMainService {
return getLastActiveWindow(WindowsManager.WINDOWS);
}
getLastActiveWindowForAuthority(remoteAuthority: string): ICodeWindow {
return getLastActiveWindow(WindowsManager.WINDOWS.filter(w => w.remoteAuthority === remoteAuthority));
}
openNewWindow(context: OpenContext, options?: INewWindowOptions): ICodeWindow[] {
let cli = this.environmentService.args;
let remote = options && options.remoteAuthority || void 0;
if (cli && (cli.remote !== remote)) {
cli = { ...cli, remote };
}
return this.open({ context, cli, forceNewWindow: true, forceEmpty: true });
}

8
src/vs/code/node/paths.ts
View file

@ -35,7 +35,7 @@ function doValidatePaths(args: string[], gotoLineMode?: boolean): string[] {
const result = args.map(arg => {
let pathCandidate = String(arg);
let parsedPath: IPathWithLineAndColumn;
let parsedPath: IPathWithLineAndColumn | undefined = undefined;
if (gotoLineMode) {
parsedPath = parseLineAndColumnAware(pathCandidate);
pathCandidate = parsedPath.path;
@ -52,7 +52,7 @@ function doValidatePaths(args: string[], gotoLineMode?: boolean): string[] {
return null; // do not allow invalid file names
}
if (gotoLineMode) {
if (gotoLineMode && parsedPath) {
parsedPath.path = sanitizedFilePath;
return toPath(parsedPath);
@ -62,7 +62,7 @@ function doValidatePaths(args: string[], gotoLineMode?: boolean): string[] {
});
const caseInsensitive = platform.isWindows || platform.isMacintosh;
const distinct = arrays.distinct(result, e => e && caseInsensitive ? e.toLowerCase() : e);
const distinct = arrays.distinct(result, e => e && caseInsensitive ? e.toLowerCase() : (e || ''));
return arrays.coalesce(distinct);
}
@ -98,7 +98,7 @@ export interface IPathWithLineAndColumn {
export function parseLineAndColumnAware(rawPath: string): IPathWithLineAndColumn {
const segments = rawPath.split(':'); // C:\file.txt:<line>:<column>
let path: string;
let path: string | null = null;
let line: number | null = null;
let column: number | null = null;

2
src/vs/css.build.js
View file

@ -319,7 +319,7 @@ var CSSBuildLoaderPlugin;
global.cssInlinedResources = global.cssInlinedResources || [];
var normalizedFSPath = fsPath.replace(/\\/g, '/');
if (global.cssInlinedResources.indexOf(normalizedFSPath) >= 0) {
console.warn('CSS INLINING IMAGE AT ' + fsPath + ' MORE THAN ONCE. CONSIDER CONSOLIDATING CSS RULES');
// console.warn('CSS INLINING IMAGE AT ' + fsPath + ' MORE THAN ONCE. CONSIDER CONSOLIDATING CSS RULES');
}
global.cssInlinedResources.push(normalizedFSPath);
var MIME = /\.svg$/.test(url) ? 'image/svg+xml' : 'image/png';

12
src/vs/editor/browser/services/codeEditorServiceImpl.ts
View file

@ -401,11 +401,7 @@ class DecorationCSSRules {
if (typeof opts !== 'undefined') {
this.collectBorderSettingsCSSText(opts, cssTextArr);
if (typeof opts.contentIconPath !== 'undefined') {
if (typeof opts.contentIconPath === 'string') {
cssTextArr.push(strings.format(_CSS_MAP.contentIconPath, URI.file(opts.contentIconPath).toString().replace(/'/g, '%27')));
} else {
cssTextArr.push(strings.format(_CSS_MAP.contentIconPath, URI.revive(opts.contentIconPath).toString(true).replace(/'/g, '%27')));
}
cssTextArr.push(strings.format(_CSS_MAP.contentIconPath, URI.revive(opts.contentIconPath).toString(true).replace(/'/g, '%27')));
}
if (typeof opts.contentText === 'string') {
const truncated = opts.contentText.match(/^.*$/m)![0]; // only take first line
@ -432,11 +428,7 @@ class DecorationCSSRules {
let cssTextArr: string[] = [];
if (typeof opts.gutterIconPath !== 'undefined') {
if (typeof opts.gutterIconPath === 'string') {
cssTextArr.push(strings.format(_CSS_MAP.gutterIconPath, URI.file(opts.gutterIconPath).toString()));
} else {
cssTextArr.push(strings.format(_CSS_MAP.gutterIconPath, URI.revive(opts.gutterIconPath).toString(true).replace(/'/g, '%27')));
}
cssTextArr.push(strings.format(_CSS_MAP.gutterIconPath, URI.revive(opts.gutterIconPath).toString(true).replace(/'/g, '%27')));
if (typeof opts.gutterIconSize !== 'undefined') {
cssTextArr.push(strings.format(_CSS_MAP.gutterIconSize, opts.gutterIconSize));
}

6
src/vs/editor/common/editorCommon.ts
View file

@ -534,10 +534,10 @@ export interface IThemeDecorationRenderOptions {
textDecoration?: string;
cursor?: string;
color?: string | ThemeColor;
opacity?: number;
opacity?: string;
letterSpacing?: string;
gutterIconPath?: string | UriComponents;
gutterIconPath?: UriComponents;
gutterIconSize?: string;
overviewRulerColor?: string | ThemeColor;
@ -551,7 +551,7 @@ export interface IThemeDecorationRenderOptions {
*/
export interface IContentDecorationRenderOptions {
contentText?: string;
contentIconPath?: string | UriComponents;
contentIconPath?: UriComponents;
border?: string;
borderColor?: string | ThemeColor;

2
src/vs/editor/common/services/getIconClasses.ts
View file

@ -3,8 +3,6 @@
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
'use strict';
import { Schemas } from 'vs/base/common/network';
import { DataUri, basenameOrAuthority } from 'vs/base/common/resources';
import { URI as uri } from 'vs/base/common/uri';

30
src/vs/editor/contrib/codeAction/codeActionWidget.ts
View file

@ -29,7 +29,7 @@ export class CodeActionContextMenu {
show(fixes: Thenable<CodeAction[]>, at: { x: number; y: number } | Position) {
const actions = fixes ? fixes.then(value => {
const actionsPromise = fixes ? fixes.then(value => {
return value.map(action => {
return new Action(action.command ? action.command.id : action.title, action.title, undefined, true, () => {
return always(
@ -45,19 +45,21 @@ export class CodeActionContextMenu {
return actions;
}) : Promise.resolve([] as Action[]);
this._contextMenuService.showContextMenu({
getAnchor: () => {
if (Position.isIPosition(at)) {
at = this._toCoords(at);
}
return at;
},
getActions: () => actions,
onHide: () => {
this._visible = false;
this._editor.focus();
},
autoSelectFirstItem: true
actionsPromise.then(actions => {
this._contextMenuService.showContextMenu({
getAnchor: () => {
if (Position.isIPosition(at)) {
at = this._toCoords(at);
}
return at;
},
getActions: () => actions,
onHide: () => {
this._visible = false;
this._editor.focus();
},
autoSelectFirstItem: true
});
});
}

4
src/vs/editor/contrib/contextmenu/contextmenu.ts
View file

@ -168,9 +168,7 @@ export class ContextMenuController implements IEditorContribution {
this._contextMenuService.showContextMenu({
getAnchor: () => anchor,
getActions: () => {
return Promise.resolve(actions);
},
getActions: () => actions,
getActionItem: (action) => {
const keybinding = this._keybindingFor(action);

8
src/vs/editor/contrib/goToDefinition/goToDefinitionMouse.ts
View file

@ -73,6 +73,12 @@ class GotoDefinitionWithMouseEditorContribution implements editorCommon.IEditorC
}
private startFindDefinition(mouseEvent: ClickLinkMouseEvent, withKey?: ClickLinkKeyboardEvent): void {
// check if we are active and on a content widget
if (mouseEvent.target.type === MouseTargetType.CONTENT_WIDGET && this.decorations.length > 0) {
return;
}
if (!this.isEnabled(mouseEvent, withKey)) {
this.currentWordUnderMouse = null;
this.removeDecorations();
@ -270,7 +276,7 @@ class GotoDefinitionWithMouseEditorContribution implements editorCommon.IEditorC
private isEnabled(mouseEvent: ClickLinkMouseEvent, withKey?: ClickLinkKeyboardEvent): boolean {
return this.editor.getModel() &&
mouseEvent.isNoneOrSingleMouseDown &&
mouseEvent.target.type === MouseTargetType.CONTENT_TEXT &&
(mouseEvent.target.type === MouseTargetType.CONTENT_TEXT) &&
(mouseEvent.hasTriggerModifier || (withKey && withKey.keyCodeIsTriggerKey)) &&
DefinitionProviderRegistry.has(this.editor.getModel());
}

4
src/vs/editor/contrib/referenceSearch/referenceSearch.ts
View file

@ -60,8 +60,8 @@ export class ReferenceAction extends EditorAction {
constructor() {
super({
id: 'editor.action.referenceSearch.trigger',
label: nls.localize('references.action.label', "Find All References"),
alias: 'Find All References',
label: nls.localize('references.action.label', "Peek References"),
alias: 'Find All References', // leave the alias?
precondition: ContextKeyExpr.and(
EditorContextKeys.hasReferenceProvider,
PeekContext.notInPeekEditor,

38
src/vs/editor/standalone/browser/simpleServices.ts
View file

@ -12,7 +12,6 @@ import { IDisposable, IReference, ImmortalReference, combinedDisposable, toDispo
import { OS, isLinux, isMacintosh } from 'vs/base/common/platform';
import Severity from 'vs/base/common/severity';
import { URI } from 'vs/base/common/uri';
import { TPromise } from 'vs/base/common/winjs.base';
import { ICodeEditor, IDiffEditor, isCodeEditor } from 'vs/editor/browser/editorBrowser';
import { IBulkEditOptions, IBulkEditResult, IBulkEditService } from 'vs/editor/browser/services/bulkEditService';
import { isDiffEditorConfigurationKey, isEditorConfigurationKey } from 'vs/editor/common/config/commonEditorConfig';
@ -25,8 +24,6 @@ import { TextEdit, WorkspaceEdit, isResourceTextEdit } from 'vs/editor/common/mo
import { IModelService } from 'vs/editor/common/services/modelService';
import { ITextEditorModel, ITextModelContentProvider, ITextModelService } from 'vs/editor/common/services/resolverService';
import { ITextResourceConfigurationService, ITextResourcePropertiesService } from 'vs/editor/common/services/resourceConfiguration';
import { IMenu, IMenuService, MenuId } from 'vs/platform/actions/common/actions';
import { Menu } from 'vs/platform/actions/common/menu';
import { CommandsRegistry, ICommand, ICommandEvent, ICommandHandler, ICommandService } from 'vs/platform/commands/common/commands';
import { IConfigurationChangeEvent, IConfigurationData, IConfigurationOverrides, IConfigurationService } from 'vs/platform/configuration/common/configuration';
import { Configuration, ConfigurationModel, DefaultConfigurationModel } from 'vs/platform/configuration/common/configurationModels';
@ -60,8 +57,8 @@ export class SimpleModel implements ITextEditorModel {
return this._onDispose.event;
}
public load(): TPromise<SimpleModel> {
return TPromise.as(this);
public load(): Promise<SimpleModel> {
return Promise.resolve(this);
}
public get textEditorModel(): ITextModel {
@ -100,7 +97,7 @@ export class SimpleEditorModelResolverService implements ITextModelService {
this.editor = editor;
}
public createModelReference(resource: URI): TPromise<IReference<ITextEditorModel>> {
public createModelReference(resource: URI): Promise<IReference<ITextEditorModel>> {
let model: ITextModel;
model = withTypedEditor(this.editor,
@ -109,10 +106,10 @@ export class SimpleEditorModelResolverService implements ITextModelService {
);
if (!model) {
return TPromise.as(new ImmortalReference(null));
return Promise.resolve(new ImmortalReference(null));
}
return TPromise.as(new ImmortalReference(new SimpleModel(model)));
return Promise.resolve(new ImmortalReference(new SimpleModel(model)));
}
public registerTextModelContentProvider(scheme: string, provider: ITextModelContentProvider): IDisposable {
@ -479,31 +476,16 @@ export class SimpleResourcePropertiesService implements ITextResourcePropertiesS
}
}
export class SimpleMenuService implements IMenuService {
_serviceBrand: any;
private readonly _commandService: ICommandService;
constructor(commandService: ICommandService) {
this._commandService = commandService;
}
public createMenu(id: MenuId, contextKeyService: IContextKeyService): IMenu {
return new Menu(id, Promise.resolve(true), this._commandService, contextKeyService);
}
}
export class StandaloneTelemetryService implements ITelemetryService {
_serviceBrand: void;
public isOptedIn = false;
public publicLog(eventName: string, data?: any): TPromise<void> {
return TPromise.wrap<void>(null);
public publicLog(eventName: string, data?: any): Promise<void> {
return Promise.resolve(null);
}
public getTelemetryInfo(): TPromise<ITelemetryInfo> {
public getTelemetryInfo(): Promise<ITelemetryInfo> {
return null;
}
}
@ -635,4 +617,8 @@ export class SimpleUriLabelService implements ILabelService {
public registerFormatter(selector: string, formatter: LabelRules): IDisposable {
throw new Error('Not implemented');
}
public getHostLabel(): string {
return '';
}
}

5
src/vs/editor/standalone/browser/standaloneServices.ts
View file

@ -13,7 +13,7 @@ import { ModeServiceImpl } from 'vs/editor/common/services/modeServiceImpl';
import { IModelService } from 'vs/editor/common/services/modelService';
import { ModelServiceImpl } from 'vs/editor/common/services/modelServiceImpl';
import { ITextResourceConfigurationService, ITextResourcePropertiesService } from 'vs/editor/common/services/resourceConfiguration';
import { SimpleBulkEditService, SimpleConfigurationService, SimpleDialogService, SimpleMenuService, SimpleNotificationService, SimpleProgressService, SimpleResourceConfigurationService, SimpleResourcePropertiesService, SimpleUriLabelService, SimpleWorkspaceContextService, StandaloneCommandService, StandaloneKeybindingService, StandaloneTelemetryService } from 'vs/editor/standalone/browser/simpleServices';
import { SimpleBulkEditService, SimpleConfigurationService, SimpleDialogService, SimpleNotificationService, SimpleProgressService, SimpleResourceConfigurationService, SimpleResourcePropertiesService, SimpleUriLabelService, SimpleWorkspaceContextService, StandaloneCommandService, StandaloneKeybindingService, StandaloneTelemetryService } from 'vs/editor/standalone/browser/simpleServices';
import { StandaloneCodeEditorServiceImpl } from 'vs/editor/standalone/browser/standaloneCodeServiceImpl';
import { StandaloneThemeServiceImpl } from 'vs/editor/standalone/browser/standaloneThemeServiceImpl';
import { IStandaloneThemeService } from 'vs/editor/standalone/common/standaloneThemeService';
@ -41,6 +41,7 @@ import { IStorageService, NullStorageService } from 'vs/platform/storage/common/
import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
import { IThemeService } from 'vs/platform/theme/common/themeService';
import { IWorkspaceContextService } from 'vs/platform/workspace/common/workspace';
import { MenuService } from 'vs/platform/actions/common/menuService';
export interface IEditorOverrideServices {
[index: string]: any;
@ -189,7 +190,7 @@ export class DynamicStandaloneServices extends Disposable {
ensure(IContextMenuService, () => this._register(new ContextMenuService(domElement, telemetryService, notificationService, contextViewService, keybindingService, themeService)));
ensure(IMenuService, () => new SimpleMenuService(commandService));
ensure(IMenuService, () => new MenuService(commandService));
ensure(IBulkEditService, () => new SimpleBulkEditService(StaticServices.modelService.get(IModelService)));
}

6
src/vs/editor/test/browser/services/decorationRenderOptions.test.ts
View file

@ -134,7 +134,7 @@ suite('Decoration Render Options', () => {
// unix file path (used as string)
let s = new TestCodeEditorServiceImpl(themeServiceMock, styleSheet);
s.registerDecorationType('example', { gutterIconPath: '/Users/foo/bar.png' });
s.registerDecorationType('example', { gutterIconPath: URI.file('/Users/foo/bar.png') });
let sheet = readStyleSheet(styleSheet);//.innerHTML || styleSheet.sheet.toString();
assert(
sheet.indexOf('background: url(\'file:///Users/foo/bar.png\') center center no-repeat;') > 0
@ -143,7 +143,7 @@ suite('Decoration Render Options', () => {
// windows file path (used as string)
s = new TestCodeEditorServiceImpl(themeServiceMock, styleSheet);
s.registerDecorationType('example', { gutterIconPath: 'c:\\files\\miles\\more.png' });
s.registerDecorationType('example', { gutterIconPath: URI.file('c:\\files\\miles\\more.png') });
sheet = readStyleSheet(styleSheet);
// TODO@Alex test fails
// assert(
@ -162,7 +162,7 @@ suite('Decoration Render Options', () => {
// single quote must always be escaped/encoded
s = new TestCodeEditorServiceImpl(themeServiceMock, styleSheet);
s.registerDecorationType('example', { gutterIconPath: '/Users/foo/b\'ar.png' });
s.registerDecorationType('example', { gutterIconPath: URI.file('/Users/foo/b\'ar.png') });
sheet = readStyleSheet(styleSheet);
assert(
sheet.indexOf('background: url(\'file:///Users/foo/b%27ar.png\') center center no-repeat;') > 0

100
src/vs/platform/actions/common/actions.ts
View file

@ -10,7 +10,7 @@ import { IKeybindings } from 'vs/platform/keybinding/common/keybindingsRegistry'
import { ContextKeyExpr, IContextKeyService } from 'vs/platform/contextkey/common/contextkey';
import { ICommandService } from 'vs/platform/commands/common/commands';
import { IDisposable } from 'vs/base/common/lifecycle';
import { Event } from 'vs/base/common/event';
import { Event, Emitter } from 'vs/base/common/event';
import { URI, UriComponents } from 'vs/base/common/uri';
export interface ILocalizedString {
@ -58,49 +58,44 @@ export function isISubmenuItem(item: IMenuItem | ISubmenuItem): item is ISubmenu
return (item as ISubmenuItem).submenu !== undefined;
}
export class MenuId {
private static ID = 1;
static readonly EditorTitle = new MenuId();
static readonly EditorTitleContext = new MenuId();
static readonly EditorContext = new MenuId();
static readonly EmptyEditorGroupContext = new MenuId();
static readonly ExplorerContext = new MenuId();
static readonly OpenEditorsContext = new MenuId();
static readonly ProblemsPanelContext = new MenuId();
static readonly DebugVariablesContext = new MenuId();
static readonly DebugWatchContext = new MenuId();
static readonly DebugCallStackContext = new MenuId();
static readonly DebugBreakpointsContext = new MenuId();
static readonly DebugConsoleContext = new MenuId();
static readonly SCMTitle = new MenuId();
static readonly SCMSourceControl = new MenuId();
static readonly SCMResourceGroupContext = new MenuId();
static readonly SCMResourceContext = new MenuId();
static readonly SCMChangeContext = new MenuId();
static readonly CommandPalette = new MenuId();
static readonly ViewTitle = new MenuId();
static readonly ViewItemContext = new MenuId();
static readonly TouchBarContext = new MenuId();
static readonly SearchContext = new MenuId();
static readonly MenubarFileMenu = new MenuId();
static readonly MenubarEditMenu = new MenuId();
static readonly MenubarRecentMenu = new MenuId();
static readonly MenubarSelectionMenu = new MenuId();
static readonly MenubarViewMenu = new MenuId();
static readonly MenubarAppearanceMenu = new MenuId();
static readonly MenubarLayoutMenu = new MenuId();
static readonly MenubarGoMenu = new MenuId();
static readonly MenubarSwitchEditorMenu = new MenuId();
static readonly MenubarSwitchGroupMenu = new MenuId();
static readonly MenubarDebugMenu = new MenuId();
static readonly MenubarNewBreakpointMenu = new MenuId();
static readonly MenubarPreferencesMenu = new MenuId();
static readonly MenubarHelpMenu = new MenuId();
static readonly MenubarTerminalMenu = new MenuId();
readonly id: string = String(MenuId.ID++);
export const enum MenuId {
CommandPalette,
DebugBreakpointsContext,
DebugCallStackContext,
DebugConsoleContext,
DebugVariablesContext,
DebugWatchContext,
EditorContext,
EditorTitle,
EditorTitleContext,
EmptyEditorGroupContext,
ExplorerContext,
MenubarAppearanceMenu,
MenubarDebugMenu,
MenubarEditMenu,
MenubarFileMenu,
MenubarGoMenu,
MenubarHelpMenu,
MenubarLayoutMenu,
MenubarNewBreakpointMenu,
MenubarPreferencesMenu,
MenubarRecentMenu,
MenubarSelectionMenu,
MenubarSwitchEditorMenu,
MenubarSwitchGroupMenu,
MenubarTerminalMenu,
MenubarViewMenu,
OpenEditorsContext,
ProblemsPanelContext,
SCMChangeContext,
SCMResourceContext,
SCMResourceGroupContext,
SCMSourceControl,
SCMTitle,
SearchContext,
TouchBarContext,
ViewItemContext,
ViewTitle,
}
export interface IMenuActionOptions {
@ -128,6 +123,7 @@ export interface IMenuRegistry {
getCommands(): ICommandsMap;
appendMenuItem(menu: MenuId, item: IMenuItem | ISubmenuItem): IDisposable;
getMenuItems(loc: MenuId): (IMenuItem | ISubmenuItem)[];
onDidChangeMenu: Event<MenuId>;
}
export interface ICommandsMap {
@ -136,9 +132,11 @@ export interface ICommandsMap {
export const MenuRegistry: IMenuRegistry = new class implements IMenuRegistry {
private _commands: { [id: string]: ICommandAction } = Object.create(null);
private readonly _commands: { [id: string]: ICommandAction } = Object.create(null);
private readonly _menuItems: { [loc: string]: (IMenuItem | ISubmenuItem)[] } = Object.create(null);
private readonly _onDidChangeMenu = new Emitter<MenuId>();
private _menuItems: { [loc: string]: (IMenuItem | ISubmenuItem)[] } = Object.create(null);
readonly onDidChangeMenu: Event<MenuId> = this._onDidChangeMenu.event;
addCommand(command: ICommandAction): boolean {
const old = this._commands[command.id];
@ -158,27 +156,29 @@ export const MenuRegistry: IMenuRegistry = new class implements IMenuRegistry {
return result;
}
appendMenuItem({ id }: MenuId, item: IMenuItem | ISubmenuItem): IDisposable {
appendMenuItem(id: MenuId, item: IMenuItem | ISubmenuItem): IDisposable {
let array = this._menuItems[id];
if (!array) {
this._menuItems[id] = array = [item];
} else {
array.push(item);
}
this._onDidChangeMenu.fire(id);
return {
dispose() {
dispose: () => {
const idx = array.indexOf(item);
if (idx >= 0) {
array.splice(idx, 1);
this._onDidChangeMenu.fire(id);
}
}
};
}
getMenuItems({ id }: MenuId): (IMenuItem | ISubmenuItem)[] {
getMenuItems(id: MenuId): (IMenuItem | ISubmenuItem)[] {
const result = this._menuItems[id] || [];
if (id === MenuId.CommandPalette.id) {
if (id === MenuId.CommandPalette) {
// CommandPalette is special because it shows
// all commands by default
this._appendImplicitItems(result);

93
src/vs/platform/actions/common/menu.ts
View file

@ -3,7 +3,7 @@
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { Event, Emitter } from 'vs/base/common/event';
import { Event, Emitter, filterEvent, debounceEvent } from 'vs/base/common/event';
import { IDisposable, dispose } from 'vs/base/common/lifecycle';
import { ContextKeyExpr, IContextKeyService } from 'vs/platform/contextkey/common/contextkey';
import { MenuId, MenuRegistry, MenuItemAction, IMenu, IMenuItem, IMenuActionOptions, ISubmenuItem, SubmenuItemAction, isIMenuItem } from 'vs/platform/actions/common/actions';
@ -13,59 +13,74 @@ type MenuItemGroup = [string, (IMenuItem | ISubmenuItem)[]];
export class Menu implements IMenu {
private _menuGroups: MenuItemGroup[] = [];
private _disposables: IDisposable[] = [];
private _onDidChange = new Emitter<IMenu>();
private readonly _onDidChange = new Emitter<IMenu>();
private readonly _disposables: IDisposable[] = [];
private _menuGroups: MenuItemGroup[];
private _contextKeys: Set<string>;
constructor(
id: MenuId,
startupSignal: Thenable<boolean>,
private readonly _id: MenuId,
@ICommandService private readonly _commandService: ICommandService,
@IContextKeyService private readonly _contextKeyService: IContextKeyService
) {
startupSignal.then(_ => {
const menuItems = MenuRegistry.getMenuItems(id);
const keysFilter = new Set<string>();
this._build();
let group: MenuItemGroup | undefined;
menuItems.sort(Menu._compareMenuItems);
// rebuild this menu whenever the menu registry reports an
// event for this MenuId
debounceEvent(
filterEvent(MenuRegistry.onDidChangeMenu, menuId => menuId === this._id),
() => { },
100
)(this._build, this, this._disposables);
for (let item of menuItems) {
// group by groupId
const groupName = item.group;
if (!group || group[0] !== groupName) {
group = [groupName || '', []];
this._menuGroups.push(group);
}
group![1].push(item);
// when context keys change we need to change if the menu also
// has changed
this._contextKeyService.onDidChangeContext(event => {
if (event.affectsSome(this._contextKeys)) {
this._onDidChange.fire();
}
}, this, this._disposables);
}
// keep keys for eventing
Menu._fillInKbExprKeys(item.when, keysFilter);
private _build(): void {
// keep precondition keys for event if applicable
if (isIMenuItem(item) && item.command.precondition) {
Menu._fillInKbExprKeys(item.command.precondition, keysFilter);
}
// reset
this._menuGroups = [];
this._contextKeys = new Set();
// keep toggled keys for event if applicable
if (isIMenuItem(item) && item.command.toggled) {
Menu._fillInKbExprKeys(item.command.toggled, keysFilter);
}
const menuItems = MenuRegistry.getMenuItems(this._id);
let group: MenuItemGroup | undefined;
menuItems.sort(Menu._compareMenuItems);
for (let item of menuItems) {
// group by groupId
const groupName = item.group;
if (!group || group[0] !== groupName) {
group = [groupName || '', []];
this._menuGroups.push(group);
}
group![1].push(item);
// keep keys for eventing
Menu._fillInKbExprKeys(item.when, this._contextKeys);
// keep precondition keys for event if applicable
if (isIMenuItem(item) && item.command.precondition) {
Menu._fillInKbExprKeys(item.command.precondition, this._contextKeys);
}
// subscribe to context changes
this._disposables.push(this._contextKeyService.onDidChangeContext(event => {
if (event.affectsSome(keysFilter)) {
this._onDidChange.fire();
}
}));
this._onDidChange.fire(this);
});
// keep toggled keys for event if applicable
if (isIMenuItem(item) && item.command.toggled) {
Menu._fillInKbExprKeys(item.command.toggled, this._contextKeys);
}
}
this._onDidChange.fire(this);
}
dispose() {
this._disposables = dispose(this._disposables);
dispose(this._disposables);
this._onDidChange.dispose();
}

4
src/vs/workbench/services/actions/common/menuService.ts → src/vs/platform/actions/common/menuService.ts
View file

@ -6,7 +6,6 @@
import { IContextKeyService } from 'vs/platform/contextkey/common/contextkey';
import { MenuId, IMenu, IMenuService } from 'vs/platform/actions/common/actions';
import { Menu } from 'vs/platform/actions/common/menu';
import { IExtensionService } from 'vs/workbench/services/extensions/common/extensions';
import { ICommandService } from 'vs/platform/commands/common/commands';
export class MenuService implements IMenuService {
@ -14,13 +13,12 @@ export class MenuService implements IMenuService {
_serviceBrand: any;
constructor(
@IExtensionService private readonly _extensionService: IExtensionService,
@ICommandService private readonly _commandService: ICommandService
) {
//
}
createMenu(id: MenuId, contextKeyService: IContextKeyService): IMenu {
return new Menu(id, this._extensionService.whenInstalledExtensionsRegistered(), this._commandService, contextKeyService);
return new Menu(id, this._commandService, contextKeyService);
}
}

10
src/vs/workbench/services/actions/test/common/menuService.test.ts → src/vs/platform/actions/test/common/menuService.test.ts
View file

@ -2,18 +2,16 @@
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as assert from 'assert';
import { MenuRegistry, MenuId, isIMenuItem } from 'vs/platform/actions/common/actions';
import { MenuService } from 'vs/workbench/services/actions/common/menuService';
import { MenuService } from 'vs/platform/actions/common/menuService';
import { IDisposable, dispose } from 'vs/base/common/lifecycle';
import { NullCommandService } from 'vs/platform/commands/common/commands';
import { MockContextKeyService } from 'vs/platform/keybinding/test/common/mockKeybindingService';
import { TestExtensionService } from 'vs/workbench/test/workbenchTestServices';
// --- service instances
const extensionService = new TestExtensionService();
const contextKeyService = new class extends MockContextKeyService {
contextMatchesRules() {
return true;
@ -29,8 +27,8 @@ suite('MenuService', function () {
let testMenuId: MenuId;
setup(function () {
menuService = new MenuService(extensionService, NullCommandService);
testMenuId = new MenuId();
menuService = new MenuService(NullCommandService);
testMenuId = Math.PI;
disposables = [];
});

1
src/vs/platform/backup/common/backup.ts
View file

@ -21,6 +21,7 @@ export const IBackupMainService = createDecorator<IBackupMainService>('backupMai
export interface IEmptyWindowBackupInfo {
backupFolder: string;
remoteAuthority?: string;
}
export interface IBackupMainService {

3
src/vs/platform/backup/electron-main/backupMainService.ts
View file

@ -139,12 +139,13 @@ export class BackupMainService implements IBackupMainService {
public registerEmptyWindowBackupSync(backupInfo: IEmptyWindowBackupInfo): string {
let backupFolder = backupInfo.backupFolder;
let remoteAuthority = backupInfo.remoteAuthority;
// Generate a new folder if this is a new empty workspace
if (!backupFolder) {
backupFolder = this.getRandomEmptyWindowId();
}
if (!this.emptyWorkspaces.some(w => isEqual(w.backupFolder, backupFolder, !platform.isLinux))) {
this.emptyWorkspaces.push({ backupFolder });
this.emptyWorkspaces.push({ backupFolder, remoteAuthority });
this.saveSync();
}
return this.getBackupPath(backupFolder);

95
src/vs/platform/contextview/browser/contextMenuHandler.ts
View file

@ -7,7 +7,7 @@ import 'vs/css!./contextMenuHandler';
import { combinedDisposable, IDisposable, dispose } from 'vs/base/common/lifecycle';
import { StandardMouseEvent } from 'vs/base/browser/mouseEvent';
import { ActionRunner, IAction, IRunEvent } from 'vs/base/common/actions';
import { ActionRunner, IRunEvent } from 'vs/base/common/actions';
import { Menu } from 'vs/base/browser/ui/menu/menu';
import { IContextViewService } from 'vs/platform/contextview/browser/contextView';
@ -50,58 +50,57 @@ export class ContextMenuHandler {
}
showContextMenu(delegate: IContextMenuDelegate): void {
delegate.getActions().then((actions: IAction[]) => {
if (!actions.length) {
return; // Don't render an empty context menu
}
const actions = delegate.getActions();
if (!actions.length) {
return; // Don't render an empty context menu
}
this.focusToReturn = document.activeElement as HTMLElement;
this.focusToReturn = document.activeElement as HTMLElement;
this.contextViewService.showContextView({
getAnchor: () => delegate.getAnchor(),
canRelayout: false,
this.contextViewService.showContextView({
getAnchor: () => delegate.getAnchor(),
canRelayout: false,
render: (container) => {
this.menuContainerElement = container;
render: (container) => {
this.menuContainerElement = container;
let className = delegate.getMenuClassName ? delegate.getMenuClassName() : '';
let className = delegate.getMenuClassName ? delegate.getMenuClassName() : '';
if (className) {
container.className += ' ' + className;
}
const menuDisposables: IDisposable[] = [];
const actionRunner = delegate.actionRunner || new ActionRunner();
actionRunner.onDidBeforeRun(this.onActionRun, this, menuDisposables);
actionRunner.onDidRun(this.onDidActionRun, this, menuDisposables);
const menu = new Menu(container, actions, {
actionItemProvider: delegate.getActionItem,
context: delegate.getActionsContext ? delegate.getActionsContext() : null,
actionRunner,
getKeyBinding: delegate.getKeyBinding ? delegate.getKeyBinding : action => this.keybindingService.lookupKeybinding(action.id)
});
menuDisposables.push(attachMenuStyler(menu, this.themeService));
menu.onDidCancel(() => this.contextViewService.hideContextView(true), null, menuDisposables);
menu.onDidBlur(() => this.contextViewService.hideContextView(true), null, menuDisposables);
domEvent(window, EventType.BLUR)(() => { this.contextViewService.hideContextView(true); }, null, menuDisposables);
menu.focus(!!delegate.autoSelectFirstItem);
return combinedDisposable([...menuDisposables, menu]);
},
onHide: (didCancel?: boolean) => {
if (delegate.onHide) {
delegate.onHide(didCancel);
}
this.menuContainerElement = null;
if (className) {
container.className += ' ' + className;
}
});
const menuDisposables: IDisposable[] = [];
const actionRunner = delegate.actionRunner || new ActionRunner();
actionRunner.onDidBeforeRun(this.onActionRun, this, menuDisposables);
actionRunner.onDidRun(this.onDidActionRun, this, menuDisposables);
const menu = new Menu(container, actions, {
actionItemProvider: delegate.getActionItem,
context: delegate.getActionsContext ? delegate.getActionsContext() : null,
actionRunner,
getKeyBinding: delegate.getKeyBinding ? delegate.getKeyBinding : action => this.keybindingService.lookupKeybinding(action.id)
});
menuDisposables.push(attachMenuStyler(menu, this.themeService));
menu.onDidCancel(() => this.contextViewService.hideContextView(true), null, menuDisposables);
menu.onDidBlur(() => this.contextViewService.hideContextView(true), null, menuDisposables);
domEvent(window, EventType.BLUR)(() => { this.contextViewService.hideContextView(true); }, null, menuDisposables);
menu.focus(!!delegate.autoSelectFirstItem);
return combinedDisposable([...menuDisposables, menu]);
},
onHide: (didCancel?: boolean) => {
if (delegate.onHide) {
delegate.onHide(didCancel);
}
this.menuContainerElement = null;
}
});
}
@ -152,4 +151,4 @@ export class ContextMenuHandler {
dispose(): void {
this.setContainer(null);
}
}
}

7
src/vs/platform/dialogs/node/dialogService.ts
View file

@ -4,7 +4,6 @@
*--------------------------------------------------------------------------------------------*/
import * as readline from 'readline';
import { TPromise } from 'vs/base/common/winjs.base';
import { IDialogService, IConfirmation, IConfirmationResult } from 'vs/platform/dialogs/common/dialogs';
import Severity from 'vs/base/common/severity';
import { localize } from 'vs/nls';
@ -14,8 +13,8 @@ export class CommandLineDialogService implements IDialogService {
_serviceBrand: any;
show(severity: Severity, message: string, options: string[]): TPromise<number> {
const promise = new TPromise<number>((c, e) => {
show(severity: Severity, message: string, options: string[]): Promise<number> {
const promise = new Promise<number>((c, e) => {
const rl = readline.createInterface({
input: process.stdin,
output: process.stdout,
@ -58,7 +57,7 @@ export class CommandLineDialogService implements IDialogService {
return -1;
}
confirm(confirmation: IConfirmation): TPromise<IConfirmationResult> {
confirm(confirmation: IConfirmation): Promise<IConfirmationResult> {
return this.show(Severity.Info, confirmation.message, [confirmation.primaryButton || localize('ok', "Ok"), confirmation.secondaryButton || localize('cancel', "Cancel")]).then(index => {
return {
confirmed: index === 0

1
src/vs/platform/environment/common/environment.ts
View file

@ -68,6 +68,7 @@ export interface ParsedArgs {
'upload-logs'?: string;
'driver'?: string;
'driver-verbose'?: boolean;
remote?: string;
}
export const IEnvironmentService = createDecorator<IEnvironmentService>('environmentService');

1
src/vs/platform/environment/node/argv.ts
View file

@ -20,6 +20,7 @@ const options: minimist.Opts = {
'extensions-dir',
'folder-uri',
'file-uri',
'remote',
'extensionDevelopmentPath',
'extensionTestsPath',
'install-extension',

5
src/vs/platform/issue/common/issue.ts
View file

@ -3,7 +3,6 @@
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { TPromise } from 'vs/base/common/winjs.base';
import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
export const IIssueService = createDecorator<IIssueService>('issueService');
@ -88,6 +87,6 @@ export interface ProcessExplorerData extends WindowData {
export interface IIssueService {
_serviceBrand: any;
openReporter(data: IssueReporterData): TPromise<void>;
openProcessExplorer(data: ProcessExplorerData): TPromise<void>;
openReporter(data: IssueReporterData): Promise<void>;
openProcessExplorer(data: ProcessExplorerData): Promise<void>;
}

202
src/vs/platform/issue/electron-main/issueService.ts
View file

@ -3,7 +3,6 @@
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { TPromise, Promise } from 'vs/base/common/winjs.base';
import { localize } from 'vs/nls';
import * as objects from 'vs/base/common/objects';
import { parseArgs } from 'vs/platform/environment/node/argv';
@ -15,14 +14,15 @@ import { IEnvironmentService } from 'vs/platform/environment/common/environment'
import { isMacintosh, IProcessEnvironment } from 'vs/base/common/platform';
import { ILogService } from 'vs/platform/log/common/log';
import { IWindowsService } from 'vs/platform/windows/common/windows';
import { IWindowState } from 'vs/platform/windows/electron-main/windows';
const DEFAULT_BACKGROUND_COLOR = '#1E1E1E';
export class IssueService implements IIssueService {
_serviceBrand: any;
_issueWindow: BrowserWindow;
_issueWindow: BrowserWindow | null;
_issueParentWindow: BrowserWindow;
_processExplorerWindow: BrowserWindow;
_processExplorerWindow: BrowserWindow | null;
constructor(
private machineId: string,
@ -73,102 +73,102 @@ export class IssueService implements IIssueService {
}
openReporter(data: IssueReporterData): TPromise<void> {
this._issueParentWindow = BrowserWindow.getFocusedWindow();
const position = this.getWindowPosition(this._issueParentWindow, 700, 800);
if (!this._issueWindow) {
this._issueWindow = new BrowserWindow({
width: position.width,
height: position.height,
minWidth: 300,
minHeight: 200,
x: position.x,
y: position.y,
title: localize('issueReporter', "Issue Reporter"),
backgroundColor: data.styles.backgroundColor || DEFAULT_BACKGROUND_COLOR
});
openReporter(data: IssueReporterData): Promise<void> {
return new Promise(_ => {
this._issueParentWindow = BrowserWindow.getFocusedWindow();
const position = this.getWindowPosition(this._issueParentWindow, 700, 800);
if (!this._issueWindow) {
this._issueWindow = new BrowserWindow({
width: position.width,
height: position.height,
minWidth: 300,
minHeight: 200,
x: position.x,
y: position.y,
title: localize('issueReporter', "Issue Reporter"),
backgroundColor: data.styles.backgroundColor || DEFAULT_BACKGROUND_COLOR
});
this._issueWindow.setMenuBarVisibility(false); // workaround for now, until a menu is implemented
this._issueWindow.setMenuBarVisibility(false); // workaround for now, until a menu is implemented
// Modified when testing UI
const features: IssueReporterFeatures = {};
// Modified when testing UI
const features: IssueReporterFeatures = {};
this.logService.trace('issueService#openReporter: opening issue reporter');
this._issueWindow.loadURL(this.getIssueReporterPath(data, features));
this.logService.trace('issueService#openReporter: opening issue reporter');
this._issueWindow.loadURL(this.getIssueReporterPath(data, features));
this._issueWindow.on('close', () => this._issueWindow = null);
this._issueWindow.on('close', () => this._issueWindow = null);
this._issueParentWindow.on('closed', () => {
if (this._issueWindow) {
this._issueWindow.close();
this._issueWindow = null;
}
});
}
this._issueWindow.focus();
return TPromise.as(null);
}
openProcessExplorer(data: ProcessExplorerData): TPromise<void> {
// Create as singleton
if (!this._processExplorerWindow) {
const parentWindow = BrowserWindow.getFocusedWindow();
const position = this.getWindowPosition(parentWindow, 800, 300);
this._processExplorerWindow = new BrowserWindow({
skipTaskbar: true,
resizable: true,
width: position.width,
height: position.height,
minWidth: 300,
minHeight: 200,
x: position.x,
y: position.y,
backgroundColor: data.styles.backgroundColor,
title: localize('processExplorer', "Process Explorer")
});
this._processExplorerWindow.setMenuBarVisibility(false);
const windowConfiguration = {
appRoot: this.environmentService.appRoot,
nodeCachedDataDir: this.environmentService.nodeCachedDataDir,
windowId: this._processExplorerWindow.id,
userEnv: this.userEnv,
machineId: this.machineId,
data
};
const environment = parseArgs(process.argv);
const config = objects.assign(environment, windowConfiguration);
for (let key in config) {
if (config[key] === void 0 || config[key] === null || config[key] === '') {
delete config[key]; // only send over properties that have a true value
}
this._issueParentWindow.on('closed', () => {
if (this._issueWindow) {
this._issueWindow.close();
this._issueWindow = null;
}
});
}
this._processExplorerWindow.loadURL(`${require.toUrl('vs/code/electron-browser/processExplorer/processExplorer.html')}?config=${encodeURIComponent(JSON.stringify(config))}`);
this._processExplorerWindow.on('close', () => this._processExplorerWindow = void 0);
parentWindow.on('close', () => {
if (this._processExplorerWindow) {
this._processExplorerWindow.close();
this._processExplorerWindow = null;
}
});
}
// Focus
this._processExplorerWindow.focus();
return TPromise.as(null);
this._issueWindow.focus();
});
}
private getWindowPosition(parentWindow: BrowserWindow, defaultWidth: number, defaultHeight: number) {
openProcessExplorer(data: ProcessExplorerData): Promise<void> {
return new Promise(_ => {
// Create as singleton
if (!this._processExplorerWindow) {
const parentWindow = BrowserWindow.getFocusedWindow();
const position = this.getWindowPosition(parentWindow, 800, 300);
this._processExplorerWindow = new BrowserWindow({
skipTaskbar: true,
resizable: true,
width: position.width,
height: position.height,
minWidth: 300,
minHeight: 200,
x: position.x,
y: position.y,
backgroundColor: data.styles.backgroundColor,
title: localize('processExplorer', "Process Explorer")
});
this._processExplorerWindow.setMenuBarVisibility(false);
const windowConfiguration = {
appRoot: this.environmentService.appRoot,
nodeCachedDataDir: this.environmentService.nodeCachedDataDir,
windowId: this._processExplorerWindow.id,
userEnv: this.userEnv,
machineId: this.machineId,
data
};
const environment = parseArgs(process.argv);
const config = objects.assign(environment, windowConfiguration);
for (let key in config) {
if (config[key] === void 0 || config[key] === null || config[key] === '') {
delete config[key]; // only send over properties that have a true value
}
}
this._processExplorerWindow.loadURL(`${require.toUrl('vs/code/electron-browser/processExplorer/processExplorer.html')}?config=${encodeURIComponent(JSON.stringify(config))}`);
this._processExplorerWindow.on('close', () => this._processExplorerWindow = null);
parentWindow.on('close', () => {
if (this._processExplorerWindow) {
this._processExplorerWindow.close();
this._processExplorerWindow = null;
}
});
}
// Focus
this._processExplorerWindow.focus();
});
}
private getWindowPosition(parentWindow: BrowserWindow, defaultWidth: number, defaultHeight: number): IWindowState {
// We want the new window to open on the same display that the parent is in
let displayToUse: Electron.Display;
let displayToUse: Electron.Display | undefined;
const displays = screen.getAllDisplays();
// Single Display
@ -196,16 +196,14 @@ export class IssueService implements IIssueService {
}
}
let state = {
const state: IWindowState = {
width: defaultWidth,
height: defaultHeight,
x: undefined,
y: undefined
height: defaultHeight
};
const displayBounds = displayToUse.bounds;
state.x = displayBounds.x + (displayBounds.width / 2) - (state.width / 2);
state.y = displayBounds.y + (displayBounds.height / 2) - (state.height / 2);
state.x = displayBounds.x + (displayBounds.width / 2) - (state.width! / 2);
state.y = displayBounds.y + (displayBounds.height / 2) - (state.height! / 2);
if (displayBounds.width > 0 && displayBounds.height > 0 /* Linux X11 sessions sometimes report wrong display bounds */) {
if (state.x < displayBounds.x) {
@ -224,11 +222,11 @@ export class IssueService implements IIssueService {
state.y = displayBounds.y; // prevent window from falling out of the screen to the bottom
}
if (state.width > displayBounds.width) {
if (state.width! > displayBounds.width) {
state.width = displayBounds.width; // prevent window from exceeding display bounds width
}
if (state.height > displayBounds.height) {
if (state.height! > displayBounds.height) {
state.height = displayBounds.height; // prevent window from exceeding display bounds height
}
}
@ -236,7 +234,7 @@ export class IssueService implements IIssueService {
return state;
}
private getSystemInformation(): TPromise<SystemInfo> {
private getSystemInformation(): Promise<SystemInfo> {
return new Promise((resolve, reject) => {
this.launchService.getMainProcessInfo().then(info => {
resolve(this.diagnosticsService.getSystemInfo(info));
@ -244,7 +242,7 @@ export class IssueService implements IIssueService {
});
}
private getPerformanceInfo(): TPromise<PerformanceInfo> {
private getPerformanceInfo(): Promise<PerformanceInfo> {
return new Promise((resolve, reject) => {
this.launchService.getMainProcessInfo().then(info => {
this.diagnosticsService.getPerformanceInfo(info)
@ -259,7 +257,11 @@ export class IssueService implements IIssueService {
});
}
private getIssueReporterPath(data: IssueReporterData, features: IssueReporterFeatures) {
private getIssueReporterPath(data: IssueReporterData, features: IssueReporterFeatures): string {
if (!this._issueWindow) {
throw new Error('Issue window has been disposed');
}
const windowConfiguration = {
appRoot: this.environmentService.appRoot,
nodeCachedDataDir: this.environmentService.nodeCachedDataDir,

13
src/vs/platform/issue/node/issueIpc.ts
View file

@ -3,15 +3,14 @@
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { TPromise } from 'vs/base/common/winjs.base';
import { IChannel } from 'vs/base/parts/ipc/node/ipc';
import { IIssueService, IssueReporterData, ProcessExplorerData } from '../common/issue';
import { Event } from 'vs/base/common/event';
export interface IIssueChannel extends IChannel {
call(command: 'openIssueReporter', arg: IssueReporterData): TPromise<void>;
call(command: 'getStatusInfo'): TPromise<any>;
call(command: string, arg?: any): TPromise<any>;
call(command: 'openIssueReporter', arg: IssueReporterData): Promise<void>;
call(command: 'getStatusInfo'): Promise<any>;
call(command: string, arg?: any): Promise<any>;
}
export class IssueChannel implements IIssueChannel {
@ -22,7 +21,7 @@ export class IssueChannel implements IIssueChannel {
throw new Error(`Event not found: ${event}`);
}
call(command: string, arg?: any): TPromise<any> {
call(command: string, arg?: any): Promise<any> {
switch (command) {
case 'openIssueReporter':
return this.service.openReporter(arg);
@ -40,11 +39,11 @@ export class IssueChannelClient implements IIssueService {
constructor(private channel: IIssueChannel) { }
openReporter(data: IssueReporterData): TPromise<void> {
openReporter(data: IssueReporterData): Promise<void> {
return this.channel.call('openIssueReporter', data);
}
openProcessExplorer(data: ProcessExplorerData): TPromise<void> {
openProcessExplorer(data: ProcessExplorerData): Promise<void> {
return this.channel.call('openProcessExplorer', data);
}
}

19
src/vs/platform/label/common/label.ts
View file

@ -18,6 +18,8 @@ import { localize } from 'vs/nls';
import { isParent } from 'vs/platform/files/common/files';
import { basename, dirname, join } from 'vs/base/common/paths';
import { Schemas } from 'vs/base/common/network';
import { IWindowService } from 'vs/platform/windows/common/windows';
import { REMOTE_HOST_SCHEME } from 'vs/platform/remote/common/remoteHosts';
export interface RegisterFormatterEvent {
selector: string;
@ -33,6 +35,7 @@ export interface ILabelService {
*/
getUriLabel(resource: URI, options?: { relative?: boolean, noPrefix?: boolean }): string;
getWorkspaceLabel(workspace: (IWorkspaceIdentifier | ISingleFolderWorkspaceIdentifier | IWorkspace), options?: { verbose: boolean }): string;
getHostLabel(): string;
registerFormatter(selector: string, formatter: LabelRules): IDisposable;
onDidRegisterFormatter: Event<RegisterFormatterEvent>;
}
@ -66,7 +69,8 @@ export class LabelService implements ILabelService {
constructor(
@IEnvironmentService private environmentService: IEnvironmentService,
@IWorkspaceContextService private contextService: IWorkspaceContextService
@IWorkspaceContextService private contextService: IWorkspaceContextService,
@IWindowService private windowService: IWindowService
) { }
get onDidRegisterFormatter(): Event<RegisterFormatterEvent> {
@ -155,6 +159,19 @@ export class LabelService implements ILabelService {
return localize('workspaceName', "{0} (Workspace)", workspaceName);
}
getHostLabel(): string {
if (this.windowService) {
const authority = this.windowService.getConfiguration().remoteAuthority;
if (authority) {
const formatter = this.findFormatter(URI.from({ scheme: REMOTE_HOST_SCHEME, authority }));
if (formatter && formatter.workspace) {
return formatter.workspace.suffix;
}
}
}
return '';
}
registerFormatter(selector: string, formatter: LabelRules): IDisposable {
this.formatters[selector] = formatter;
this._onDidRegisterFormatter.fire({ selector, formatter });

4
src/vs/platform/label/test/label.test.ts
View file

@ -5,7 +5,7 @@
import * as assert from 'assert';
import { LabelService } from 'vs/platform/label/common/label';
import { TestEnvironmentService, TestContextService } from 'vs/workbench/test/workbenchTestServices';
import { TestEnvironmentService, TestContextService, TestWindowService } from 'vs/workbench/test/workbenchTestServices';
import { TestWorkspace } from 'vs/platform/workspace/test/common/testWorkspace';
import { URI } from 'vs/base/common/uri';
import { nativeSep } from 'vs/base/common/paths';
@ -16,7 +16,7 @@ suite('URI Label', () => {
let labelService: LabelService;
setup(() => {
labelService = new LabelService(TestEnvironmentService, new TestContextService());
labelService = new LabelService(TestEnvironmentService, new TestContextService(), new TestWindowService());
});
test('file scheme', function () {

9
src/vs/platform/lifecycle/common/lifecycle.ts
View file

@ -3,7 +3,6 @@
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { TPromise } from 'vs/base/common/winjs.base';
import { Event } from 'vs/base/common/event';
import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
import { isThenable } from 'vs/base/common/async';
@ -149,9 +148,9 @@ export const NullLifecycleService: ILifecycleService = {
};
// Shared veto handling across main and renderer
export function handleVetos(vetos: (boolean | Thenable<boolean>)[], onError: (error: Error) => void): TPromise<boolean /* veto */> {
export function handleVetos(vetos: (boolean | Thenable<boolean>)[], onError: (error: Error) => void): Promise<boolean /* veto */> {
if (vetos.length === 0) {
return TPromise.as(false);
return Promise.resolve(false);
}
const promises: Thenable<void>[] = [];
@ -161,7 +160,7 @@ export function handleVetos(vetos: (boolean | Thenable<boolean>)[], onError: (er
// veto, done
if (valueOrPromise === true) {
return TPromise.as(true);
return Promise.resolve(true);
}
if (isThenable(valueOrPromise)) {
@ -176,5 +175,5 @@ export function handleVetos(vetos: (boolean | Thenable<boolean>)[], onError: (er
}
}
return TPromise.join(promises).then(() => lazyValue);
return Promise.all(promises).then(() => lazyValue);
}

5
src/vs/platform/lifecycle/electron-browser/lifecycleService.ts
View file

@ -3,7 +3,6 @@
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { TPromise } from 'vs/base/common/winjs.base';
import { toErrorMessage } from 'vs/base/common/errorMessage';
import { ILifecycleService, WillShutdownEvent, ShutdownReason, StartupKind, LifecyclePhase, handleVetos, LifecyclePhaseToString, ShutdownEvent } from 'vs/platform/lifecycle/common/lifecycle';
import { IStorageService, StorageScope } from 'vs/platform/storage/common/storage';
@ -102,7 +101,7 @@ export class LifecycleService extends Disposable implements ILifecycleService {
});
}
private handleWillShutdown(reason: ShutdownReason): TPromise<boolean> {
private handleWillShutdown(reason: ShutdownReason): Promise<boolean> {
const vetos: (boolean | Thenable<boolean>)[] = [];
this._onWillShutdown.fire({
@ -130,7 +129,7 @@ export class LifecycleService extends Disposable implements ILifecycleService {
reason
});
return TPromise.join(joiners).then(() => void 0, err => {
return Promise.all(joiners).then(() => void 0, err => {
this.notificationService.error(toErrorMessage(err));
onUnexpectedError(err);
});

17
src/vs/platform/quickinput/common/quickInput.ts
View file

@ -4,7 +4,6 @@
*--------------------------------------------------------------------------------------------*/
import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
import { TPromise } from 'vs/base/common/winjs.base';
import { CancellationToken } from 'vs/base/common/cancellation';
import { ResolvedKeybinding } from 'vs/base/common/keyCodes';
import { URI } from 'vs/base/common/uri';
@ -76,7 +75,7 @@ export interface IPickOptions<T extends IQuickPickItem> {
/**
* an optional property for the item to focus initially.
*/
activeItem?: TPromise<T> | T;
activeItem?: Promise<T> | T;
onKeyMods?: (keyMods: IKeyMods) => void;
onDidFocus?: (entry: T) => void;
@ -231,14 +230,14 @@ export interface IQuickInputService {
/**
* Opens the quick input box for selecting items and returns a promise with the user selected item(s) if any.
*/
pick<T extends IQuickPickItem>(picks: TPromise<QuickPickInput<T>[]> | QuickPickInput<T>[], options?: IPickOptions<T> & { canPickMany: true }, token?: CancellationToken): TPromise<T[]>;
pick<T extends IQuickPickItem>(picks: TPromise<QuickPickInput<T>[]> | QuickPickInput<T>[], options?: IPickOptions<T> & { canPickMany: false }, token?: CancellationToken): TPromise<T>;
pick<T extends IQuickPickItem>(picks: TPromise<QuickPickInput<T>[]> | QuickPickInput<T>[], options?: Omit<IPickOptions<T>, 'canPickMany'>, token?: CancellationToken): TPromise<T>;
pick<T extends IQuickPickItem>(picks: Thenable<QuickPickInput<T>[]> | QuickPickInput<T>[], options?: IPickOptions<T> & { canPickMany: true }, token?: CancellationToken): Promise<T[]>;
pick<T extends IQuickPickItem>(picks: Thenable<QuickPickInput<T>[]> | QuickPickInput<T>[], options?: IPickOptions<T> & { canPickMany: false }, token?: CancellationToken): Promise<T>;
pick<T extends IQuickPickItem>(picks: Thenable<QuickPickInput<T>[]> | QuickPickInput<T>[], options?: Omit<IPickOptions<T>, 'canPickMany'>, token?: CancellationToken): Promise<T>;
/**
* Opens the quick input box for text input and returns a promise with the user typed value if any.
*/
input(options?: IInputOptions, token?: CancellationToken): TPromise<string>;
input(options?: IInputOptions, token?: CancellationToken): Promise<string>;
backButton: IQuickInputButton;
@ -251,9 +250,9 @@ export interface IQuickInputService {
navigate(next: boolean, quickNavigate?: IQuickNavigateConfiguration): void;
accept(): TPromise<void>;
accept(): Promise<void>;
back(): TPromise<void>;
back(): Promise<void>;
cancel(): TPromise<void>;
cancel(): Promise<void>;
}

12
src/vs/platform/remote/common/remoteHosts.ts Normal file
View file

@ -0,0 +1,12 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { URI } from 'vs/base/common/uri';
export const REMOTE_HOST_SCHEME = 'vscode-remote';
export function getRemoteAuthority(uri: URI) {
return uri.scheme === REMOTE_HOST_SCHEME ? uri.authority : void 0;
}

11
src/vs/platform/search/common/replace.ts
View file

@ -21,14 +21,18 @@ export class ReplacePattern {
let parseParameters: boolean;
if (typeof arg2 === 'boolean') {
parseParameters = arg2;
this._regExp = arg3;
} else {
searchPatternInfo = arg2;
parseParameters = searchPatternInfo.isRegExp;
parseParameters = !!searchPatternInfo.isRegExp;
this._regExp = strings.createRegExp(searchPatternInfo.pattern, !!searchPatternInfo.isRegExp, { matchCase: searchPatternInfo.isCaseSensitive, wholeWord: searchPatternInfo.isWordMatch, multiline: searchPatternInfo.isMultiline, global: false });
}
if (parseParameters) {
this.parseReplaceString(replaceString);
}
this._regExp = arg3 ? arg3 : strings.createRegExp(searchPatternInfo.pattern, searchPatternInfo.isRegExp, { matchCase: searchPatternInfo.isCaseSensitive, wholeWord: searchPatternInfo.isWordMatch, multiline: searchPatternInfo.isMultiline, global: false });
if (this._regExp.global) {
this._regExp = strings.createRegExp(this._regExp.source, true, { matchCase: !this._regExp.ignoreCase, wholeWord: false, multiline: this._regExp.multiline, global: false });
}
@ -50,7 +54,7 @@ export class ReplacePattern {
* Returns the replace string for the first match in the given text.
* If text has no matches then returns null.
*/
public getReplaceString(text: string): string {
public getReplaceString(text: string): string | null {
this._regExp.lastIndex = 0;
let match = this._regExp.exec(text);
if (match) {
@ -63,6 +67,7 @@ export class ReplacePattern {
}
return this.pattern;
}
return null;
}

14
src/vs/platform/search/common/search.ts
View file

@ -12,7 +12,7 @@ import * as objects from 'vs/base/common/objects';
import * as paths from 'vs/base/common/paths';
import { getNLines } from 'vs/base/common/strings';
import { URI, UriComponents } from 'vs/base/common/uri';
import { TPromise } from 'vs/base/common/winjs.base';
import { Promise } from 'vs/base/common/winjs.base';
import { IFilesConfiguration } from 'vs/platform/files/common/files';
import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
@ -26,10 +26,10 @@ export const ISearchService = createDecorator<ISearchService>('searchService');
*/
export interface ISearchService {
_serviceBrand: any;
textSearch(query: ITextQuery, token?: CancellationToken, onProgress?: (result: ISearchProgressItem) => void): TPromise<ISearchComplete>;
fileSearch(query: IFileQuery, token?: CancellationToken): TPromise<ISearchComplete>;
textSearch(query: ITextQuery, token?: CancellationToken, onProgress?: (result: ISearchProgressItem) => void): Promise<ISearchComplete>;
fileSearch(query: IFileQuery, token?: CancellationToken): Promise<ISearchComplete>;
extendQuery(query: ITextQuery | IFileQuery): void;
clearCache(cacheKey: string): TPromise<void>;
clearCache(cacheKey: string): Promise<void>;
registerSearchResultProvider(scheme: string, type: SearchProviderType, provider: ISearchResultProvider): IDisposable;
}
@ -58,9 +58,9 @@ export const enum SearchProviderType {
}
export interface ISearchResultProvider {
textSearch(query: ITextQuery, onProgress?: (p: ISearchProgressItem) => void, token?: CancellationToken): TPromise<ISearchComplete>;
fileSearch(query: IFileQuery, token?: CancellationToken): TPromise<ISearchComplete>;
clearCache(cacheKey: string): TPromise<void>;
textSearch(query: ITextQuery, onProgress?: (p: ISearchProgressItem) => void, token?: CancellationToken): Promise<ISearchComplete>;
fileSearch(query: IFileQuery, token?: CancellationToken): Promise<ISearchComplete>;
clearCache(cacheKey: string): Promise<void>;
}
export interface IFolderQuery<U extends UriComponents=URI> {

5
src/vs/platform/url/node/urlIpc.ts
View file

@ -3,7 +3,6 @@
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { TPromise } from 'vs/base/common/winjs.base';
import { IChannel } from 'vs/base/parts/ipc/node/ipc';
import { URI } from 'vs/base/common/uri';
import { IDisposable } from 'vs/base/common/lifecycle';
@ -73,7 +72,7 @@ export class URLHandlerChannelClient implements IURLHandler {
constructor(private channel: IChannel) { }
handleURL(uri: URI): TPromise<boolean> {
return TPromise.wrap(this.channel.call('handleURL', uri.toJSON()));
handleURL(uri: URI): Thenable<boolean> {
return this.channel.call('handleURL', uri.toJSON());
}
}

3
src/vs/platform/windows/common/windows.ts
View file

@ -83,6 +83,7 @@ export interface SaveDialogOptions {
}
export interface INewWindowOptions {
remoteAuthority?: string;
}
export interface IDevToolsOptions {
@ -345,6 +346,8 @@ export interface IWindowConfiguration extends ParsedArgs {
workspace?: IWorkspaceIdentifier;
folderUri?: ISingleFolderWorkspaceIdentifier;
remoteAuthority?: string;
zoomLevel?: number;
fullscreen?: boolean;
maximized?: boolean;

2
src/vs/platform/windows/electron-main/windows.ts
View file

@ -38,6 +38,8 @@ export interface ICodeWindow {
openedWorkspace: IWorkspaceIdentifier;
backupPath: string;
remoteAuthority: string;
isExtensionDevelopmentHost: boolean;
isExtensionTestHost: boolean;

2
src/vs/vscode.proposed.d.ts vendored
View file

@ -233,7 +233,7 @@ declare module 'vscode' {
/**
* The maximum number of results to be returned.
*/
maxResults: number;
maxResults?: number;
}
/**

2
src/vs/workbench/api/electron-browser/mainThreadClipboard.ts
View file

@ -3,8 +3,6 @@
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
'use strict';
import { clipboard } from 'electron';
import { extHostNamedCustomer } from 'vs/workbench/api/electron-browser/extHostCustomers';
import { MainContext, MainThreadClipboardShape } from '../node/extHost.protocol';

67
src/vs/workbench/api/electron-browser/mainThreadDebugService.ts
View file

@ -6,7 +6,6 @@
import { IDisposable, dispose } from 'vs/base/common/lifecycle';
import { URI as uri } from 'vs/base/common/uri';
import { IDebugService, IConfig, IDebugConfigurationProvider, IBreakpoint, IFunctionBreakpoint, IBreakpointData, ITerminalSettings, IDebugAdapter, IDebugAdapterProvider, IDebugSession } from 'vs/workbench/parts/debug/common/debug';
import { TPromise } from 'vs/base/common/winjs.base';
import {
ExtHostContext, ExtHostDebugServiceShape, MainThreadDebugServiceShape, DebugSessionUUID, MainContext,
IExtHostContext, IBreakpointsDeltaDto, ISourceMultiBreakpointDto, ISourceBreakpointDto, IFunctionBreakpointDto, IDebugSessionDto
@ -16,7 +15,6 @@ import severity from 'vs/base/common/severity';
import { AbstractDebugAdapter } from 'vs/workbench/parts/debug/node/debugAdapter';
import { IWorkspaceFolder } from 'vs/platform/workspace/common/workspace';
import { convertToVSCPaths, convertToDAPaths, stringToUri, uriToString } from 'vs/workbench/parts/debug/common/debugUtils';
import { deepClone } from 'vs/base/common/objects';
@extHostNamedCustomer(MainContext.MainThreadDebugService)
export class MainThreadDebugService implements MainThreadDebugServiceShape, IDebugAdapterProvider {
@ -26,6 +24,7 @@ export class MainThreadDebugService implements MainThreadDebugServiceShape, IDeb
private _breakpointEventsActive: boolean;
private _debugAdapters: Map<number, ExtensionHostDebugAdapter>;
private _debugAdaptersHandleCounter = 1;
private _debugConfigurationProviders: Map<number, IDebugConfigurationProvider>;
constructor(
extHostContext: IExtHostContext,
@ -47,7 +46,8 @@ export class MainThreadDebugService implements MainThreadDebugServiceShape, IDeb
this._proxy.$acceptDebugSessionActiveChanged(this.getSessionDto(session));
}));
this._debugAdapters = new Map<number, ExtensionHostDebugAdapter>();
this._debugAdapters = new Map();
this._debugConfigurationProviders = new Map();
}
public dispose(): void {
@ -63,22 +63,21 @@ export class MainThreadDebugService implements MainThreadDebugServiceShape, IDeb
return da;
}
substituteVariables(folder: IWorkspaceFolder, config: IConfig): TPromise<IConfig> {
return TPromise.wrap(this._proxy.$substituteVariables(folder ? folder.uri : undefined, config));
substituteVariables(folder: IWorkspaceFolder, config: IConfig): Promise<IConfig> {
return Promise.resolve(this._proxy.$substituteVariables(folder ? folder.uri : undefined, config));
}
runInTerminal(args: DebugProtocol.RunInTerminalRequestArguments, config: ITerminalSettings): TPromise<void> {
return TPromise.wrap(this._proxy.$runInTerminal(args, config));
runInTerminal(args: DebugProtocol.RunInTerminalRequestArguments, config: ITerminalSettings): Promise<void> {
return Promise.resolve(this._proxy.$runInTerminal(args, config));
}
// RPC methods (MainThreadDebugServiceShape)
public $registerDebugTypes(debugTypes: string[]) {
this._toDispose.push(this.debugService.getConfigurationManager().registerDebugAdapterProvider(debugTypes, this));
}
public $startBreakpointEvents(): Thenable<void> {
public $startBreakpointEvents(): void {
if (!this._breakpointEventsActive) {
this._breakpointEventsActive = true;
@ -113,8 +112,6 @@ export class MainThreadDebugService implements MainThreadDebugServiceShape, IDeb
});
}
}
return TPromise.wrap<void>(undefined);
}
public $registerBreakpoints(DTOs: (ISourceMultiBreakpointDto | IFunctionBreakpointDto)[]): Thenable<void> {
@ -155,27 +152,31 @@ export class MainThreadDebugService implements MainThreadDebugServiceShape, IDeb
};
if (hasProvide) {
provider.provideDebugConfigurations = (folder) => {
return TPromise.wrap(this._proxy.$provideDebugConfigurations(handle, folder));
return Promise.resolve(this._proxy.$provideDebugConfigurations(handle, folder));
};
}
if (hasResolve) {
provider.resolveDebugConfiguration = (folder, config) => {
return TPromise.wrap(this._proxy.$resolveDebugConfiguration(handle, folder, config));
return Promise.resolve(this._proxy.$resolveDebugConfiguration(handle, folder, config));
};
}
if (hasProvideDebugAdapter) {
provider.provideDebugAdapter = (session, folder, config) => {
return TPromise.wrap(this._proxy.$provideDebugAdapter(handle, this.getSessionDto(session), folder, config));
return Promise.resolve(this._proxy.$provideDebugAdapter(handle, this.getSessionDto(session), folder, config));
};
}
this.debugService.getConfigurationManager().registerDebugConfigurationProvider(handle, provider);
this._debugConfigurationProviders.set(handle, provider);
this._toDispose.push(this.debugService.getConfigurationManager().registerDebugConfigurationProvider(provider));
return TPromise.wrap<void>(undefined);
return Promise.resolve(undefined);
}
public $unregisterDebugConfigurationProvider(handle: number): Thenable<void> {
this.debugService.getConfigurationManager().unregisterDebugConfigurationProvider(handle);
return TPromise.wrap<void>(undefined);
public $unregisterDebugConfigurationProvider(handle: number): void {
const provider = this._debugConfigurationProviders.get(handle);
if (provider) {
this._debugConfigurationProviders.delete(handle);
this.debugService.getConfigurationManager().unregisterDebugConfigurationProvider(provider);
}
}
public $startDebugging(_folderUri: uri | undefined, nameOrConfiguration: string | IConfig): Thenable<boolean> {
@ -184,7 +185,7 @@ export class MainThreadDebugService implements MainThreadDebugServiceShape, IDeb
return this.debugService.startDebugging(launch, nameOrConfiguration).then(success => {
return success;
}, err => {
return TPromise.wrapError(new Error(err && err.message ? err.message : 'cannot start debugging'));
return Promise.reject(new Error(err && err.message ? err.message : 'cannot start debugging'));
});
}
@ -195,27 +196,24 @@ export class MainThreadDebugService implements MainThreadDebugServiceShape, IDeb
if (response && response.success) {
return response.body;
} else {
return TPromise.wrapError(new Error(response ? response.message : 'custom request failed'));
return Promise.reject(new Error(response ? response.message : 'custom request failed'));
}
});
}
return TPromise.wrapError(new Error('debug session not found'));
return Promise.reject(new Error('debug session not found'));
}
public $appendDebugConsole(value: string): Thenable<void> {
public $appendDebugConsole(value: string): void {
// Use warning as severity to get the orange color for messages coming from the debug extension
const session = this.debugService.getViewModel().focusedSession;
if (session) {
session.appendToRepl(value, severity.Warning);
}
return TPromise.wrap<void>(undefined);
}
public $acceptDAMessage(handle: number, message: DebugProtocol.ProtocolMessage) {
convertToVSCPaths(message, source => uriToString(source));
this._debugAdapters.get(handle).acceptMessage(message);
this._debugAdapters.get(handle).acceptMessage(convertToVSCPaths(message, source => uriToString(source)));
}
public $acceptDAError(handle: number, name: string, message: string, stack: string) {
@ -287,21 +285,16 @@ class ExtensionHostDebugAdapter extends AbstractDebugAdapter {
this._onExit.fire(code);
}
public startSession(): TPromise<void> {
return TPromise.wrap(this._proxy.$startDASession(this._handle, this._sessionDto, this.folder ? this.folder.uri : undefined, this.config));
public startSession(): Promise<void> {
return Promise.resolve(this._proxy.$startDASession(this._handle, this._sessionDto, this.folder ? this.folder.uri : undefined, this.config));
}
public sendMessage(message: DebugProtocol.ProtocolMessage): void {
// since we modify Source.paths in the message in place, we need to make a copy of it (see #61129)
const msg = deepClone(message);
convertToDAPaths(msg, source => stringToUri(source));
this._proxy.$sendDAMessage(this._handle, msg);
this._proxy.$sendDAMessage(this._handle, convertToDAPaths(message, source => stringToUri(source)));
}
public stopSession(): TPromise<void> {
return TPromise.wrap(this._proxy.$stopDASession(this._handle));
public stopSession(): Promise<void> {
return Promise.resolve(this._proxy.$stopDASession(this._handle));
}
}

6
src/vs/workbench/api/electron-browser/mainThreadFileSystem.ts
View file

@ -51,7 +51,7 @@ export class MainThreadFileSystem implements MainThreadFileSystemShape {
class RemoteFileSystemProvider implements IFileSystemProvider {
private readonly _onDidChange = new Emitter<IFileChange[]>();
private readonly _registrations: IDisposable[];
private readonly _registration: IDisposable;
readonly onDidChangeFile: Event<IFileChange[]> = this._onDidChange.event;
readonly capabilities: FileSystemProviderCapabilities;
@ -64,11 +64,11 @@ class RemoteFileSystemProvider implements IFileSystemProvider {
private readonly _proxy: ExtHostFileSystemShape
) {
this.capabilities = capabilities;
this._registrations = [fileService.registerProvider(scheme, this)];
this._registration = fileService.registerProvider(scheme, this);
}
dispose(): void {
dispose(this._registrations);
this._registration.dispose();
this._onDidChange.dispose();
}

28
src/vs/workbench/api/electron-browser/mainThreadTask.ts
View file

@ -11,6 +11,7 @@ import * as Objects from 'vs/base/common/objects';
import * as Types from 'vs/base/common/types';
import * as Platform from 'vs/base/common/platform';
import { IStringDictionary } from 'vs/base/common/collections';
import { IDisposable } from 'vs/base/common/lifecycle';
import { IWorkspaceContextService, IWorkspaceFolder } from 'vs/platform/workspace/common/workspace';
@ -19,9 +20,11 @@ import {
PresentationOptions, CommandOptions, CommandConfiguration, RuntimeType, CustomTask, TaskScope, TaskSource, TaskSourceKind, ExtensionTaskSource, RevealKind, PanelKind
} from 'vs/workbench/parts/tasks/common/tasks';
import { TaskDefinition } from 'vs/workbench/parts/tasks/node/tasks';
import { ITaskService, TaskFilter } from 'vs/workbench/parts/tasks/common/taskService';
import { ResolveSet, ResolvedVariables } from 'vs/workbench/parts/tasks/common/taskSystem';
import { ITaskService, TaskFilter, ITaskProvider } from 'vs/workbench/parts/tasks/common/taskService';
import { TaskDefinition } from 'vs/workbench/parts/tasks/node/tasks';
import { extHostNamedCustomer } from 'vs/workbench/api/electron-browser/extHostCustomers';
import { ExtHostContext, MainThreadTaskShape, ExtHostTaskShape, MainContext, IExtHostContext } from 'vs/workbench/api/node/extHost.protocol';
@ -29,7 +32,6 @@ import {
TaskDefinitionDTO, TaskExecutionDTO, ProcessExecutionOptionsDTO, TaskPresentationOptionsDTO,
ProcessExecutionDTO, ShellExecutionDTO, ShellExecutionOptionsDTO, TaskDTO, TaskSourceDTO, TaskHandleDTO, TaskFilterDTO, TaskProcessStartedDTO, TaskProcessEndedDTO, TaskSystemInfoDTO
} from 'vs/workbench/api/shared/tasks';
import { ResolveSet, ResolvedVariables } from 'vs/workbench/parts/tasks/common/taskSystem';
namespace TaskExecutionDTO {
export function from(value: TaskExecution): TaskExecutionDTO {
@ -362,7 +364,7 @@ export class MainThreadTask implements MainThreadTaskShape {
private _extHostContext: IExtHostContext;
private _proxy: ExtHostTaskShape;
private _activeHandles: { [handle: number]: boolean; };
private _providers: Map<number, { disposable: IDisposable, provider: ITaskProvider }>;
constructor(
extHostContext: IExtHostContext,
@ -370,7 +372,7 @@ export class MainThreadTask implements MainThreadTaskShape {
@IWorkspaceContextService private readonly _workspaceContextServer: IWorkspaceContextService
) {
this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostTask);
this._activeHandles = Object.create(null);
this._providers = new Map();
this._taskService.onDidStateChange((event: TaskEvent) => {
let task = event.__task;
if (event.kind === TaskEventKind.Start) {
@ -386,14 +388,14 @@ export class MainThreadTask implements MainThreadTaskShape {
}
public dispose(): void {
Object.keys(this._activeHandles).forEach((handle) => {
this._taskService.unregisterTaskProvider(parseInt(handle, 10));
this._providers.forEach((value) => {
value.disposable.dispose();
});
this._activeHandles = Object.create(null);
this._providers.clear();
}
public $registerTaskProvider(handle: number): Thenable<void> {
this._taskService.registerTaskProvider(handle, {
let provider: ITaskProvider = {
provideTasks: (validTypes: IStringDictionary<boolean>) => {
return Promise.resolve(this._proxy.$provideTasks(handle, validTypes)).then((value) => {
let tasks: Task[] = [];
@ -417,14 +419,14 @@ export class MainThreadTask implements MainThreadTaskShape {
return value;
});
}
});
this._activeHandles[handle] = true;
};
let disposable = this._taskService.registerTaskProvider(provider);
this._providers.set(handle, { disposable, provider });
return Promise.resolve(undefined);
}
public $unregisterTaskProvider(handle: number): Thenable<void> {
this._taskService.unregisterTaskProvider(handle);
delete this._activeHandles[handle];
this._providers.delete(handle);
return Promise.resolve(undefined);
}

83
src/vs/workbench/api/node/extHost.api.impl.ts
View file

@ -59,7 +59,7 @@ import { ExtHostUrls } from 'vs/workbench/api/node/extHostUrls';
import { ExtHostWebviews } from 'vs/workbench/api/node/extHostWebview';
import { ExtHostWindow } from 'vs/workbench/api/node/extHostWindow';
import { ExtHostWorkspace } from 'vs/workbench/api/node/extHostWorkspace';
import { IExtensionDescription, throwProposedApiError, checkProposedApiEnabled } from 'vs/workbench/services/extensions/common/extensions';
import { IExtensionDescription, throwProposedApiError, checkProposedApiEnabled, nullExtensionDescription } from 'vs/workbench/services/extensions/common/extensions';
import { ProxyIdentifier } from 'vs/workbench/services/extensions/node/proxyIdentifier';
import * as vscode from 'vscode';
@ -134,7 +134,8 @@ export function createApiFactory(
const extHostLanguages = new ExtHostLanguages(rpcProtocol, extHostDocuments);
// Register an output channel for exthost log
extHostOutputService.createOutputChannelFromLogFile(localize('extensionsLog', "Extension Host"), extHostLogService.logFile);
const name = localize('extensionsLog', "Extension Host");
extHostOutputService.createOutputChannelFromLogFile(name, extHostLogService.logFile);
// Register API-ish commands
ExtHostApiCommands.register(extHostCommands);
@ -146,7 +147,7 @@ export function createApiFactory(
// extension should specify then the `file`-scheme, e.g `{ scheme: 'fooLang', language: 'fooLang' }`
// We only inform once, it is not a warning because we just want to raise awareness and because
// we cannot say if the extension is doing it right or wrong...
let checkSelector = (function () {
const checkSelector = (function () {
let done = (!extension.isUnderDevelopment);
function informOnce(selector: vscode.DocumentSelector) {
if (!done) {
@ -171,6 +172,24 @@ export function createApiFactory(
};
})();
// Warn when trying to use the vscode.previewHtml command as it does not work properly in all scenarios and
// has security concerns.
const checkCommand = (() => {
let done = !extension.isUnderDevelopment;
const informOnce = () => {
if (!done) {
done = true;
console.warn(`Extension '${extension.id}' uses the 'vscode.previewHtml' command which is deprecated and will be removed. Please update your extension to use the Webview API: https://go.microsoft.com/fwlink/?linkid=2039309`);
}
};
return (commandId: string) => {
if (commandId === 'vscode.previewHtml') {
informOnce();
}
return commandId;
};
})();
// namespace: commands
const commands: typeof vscode.commands = {
registerCommand(id: string, command: <T>(...args: any[]) => T | Thenable<T>, thisArgs?: any): vscode.Disposable {
@ -210,7 +229,7 @@ export function createApiFactory(
});
}),
executeCommand<T>(id: string, ...args: any[]): Thenable<T> {
return extHostCommands.executeCommand<T>(id, ...args);
return extHostCommands.executeCommand<T>(checkCommand(id), ...args);
},
getCommands(filterInternal: boolean = false): Thenable<string[]> {
return extHostCommands.getCommands(filterInternal);
@ -273,64 +292,64 @@ export function createApiFactory(
return score(typeConverters.LanguageSelector.from(selector), document.uri, document.languageId, true);
},
registerCodeActionsProvider(selector: vscode.DocumentSelector, provider: vscode.CodeActionProvider, metadata?: vscode.CodeActionProviderMetadata): vscode.Disposable {
return extHostLanguageFeatures.registerCodeActionProvider(checkSelector(selector), provider, extension, metadata);
return extHostLanguageFeatures.registerCodeActionProvider(extension, checkSelector(selector), provider, metadata);
},
registerCodeLensProvider(selector: vscode.DocumentSelector, provider: vscode.CodeLensProvider): vscode.Disposable {
return extHostLanguageFeatures.registerCodeLensProvider(checkSelector(selector), provider);
return extHostLanguageFeatures.registerCodeLensProvider(extension, checkSelector(selector), provider);
},
registerDefinitionProvider(selector: vscode.DocumentSelector, provider: vscode.DefinitionProvider): vscode.Disposable {
return extHostLanguageFeatures.registerDefinitionProvider(checkSelector(selector), provider);
return extHostLanguageFeatures.registerDefinitionProvider(extension, checkSelector(selector), provider);
},
registerImplementationProvider(selector: vscode.DocumentSelector, provider: vscode.ImplementationProvider): vscode.Disposable {
return extHostLanguageFeatures.registerImplementationProvider(checkSelector(selector), provider);
return extHostLanguageFeatures.registerImplementationProvider(extension, checkSelector(selector), provider);
},
registerTypeDefinitionProvider(selector: vscode.DocumentSelector, provider: vscode.TypeDefinitionProvider): vscode.Disposable {
return extHostLanguageFeatures.registerTypeDefinitionProvider(checkSelector(selector), provider);
return extHostLanguageFeatures.registerTypeDefinitionProvider(extension, checkSelector(selector), provider);
},
registerHoverProvider(selector: vscode.DocumentSelector, provider: vscode.HoverProvider): vscode.Disposable {
return extHostLanguageFeatures.registerHoverProvider(checkSelector(selector), provider, extension.id);
return extHostLanguageFeatures.registerHoverProvider(extension, checkSelector(selector), provider, extension.id);
},
registerDocumentHighlightProvider(selector: vscode.DocumentSelector, provider: vscode.DocumentHighlightProvider): vscode.Disposable {
return extHostLanguageFeatures.registerDocumentHighlightProvider(checkSelector(selector), provider);
return extHostLanguageFeatures.registerDocumentHighlightProvider(extension, checkSelector(selector), provider);
},
registerReferenceProvider(selector: vscode.DocumentSelector, provider: vscode.ReferenceProvider): vscode.Disposable {
return extHostLanguageFeatures.registerReferenceProvider(checkSelector(selector), provider);
return extHostLanguageFeatures.registerReferenceProvider(extension, checkSelector(selector), provider);
},
registerRenameProvider(selector: vscode.DocumentSelector, provider: vscode.RenameProvider): vscode.Disposable {
return extHostLanguageFeatures.registerRenameProvider(checkSelector(selector), provider);
return extHostLanguageFeatures.registerRenameProvider(extension, checkSelector(selector), provider);
},
registerDocumentSymbolProvider(selector: vscode.DocumentSelector, provider: vscode.DocumentSymbolProvider): vscode.Disposable {
return extHostLanguageFeatures.registerDocumentSymbolProvider(checkSelector(selector), provider, extension);
return extHostLanguageFeatures.registerDocumentSymbolProvider(extension, checkSelector(selector), provider);
},
registerWorkspaceSymbolProvider(provider: vscode.WorkspaceSymbolProvider): vscode.Disposable {
return extHostLanguageFeatures.registerWorkspaceSymbolProvider(provider);
return extHostLanguageFeatures.registerWorkspaceSymbolProvider(extension, provider);
},
registerDocumentFormattingEditProvider(selector: vscode.DocumentSelector, provider: vscode.DocumentFormattingEditProvider): vscode.Disposable {
return extHostLanguageFeatures.registerDocumentFormattingEditProvider(checkSelector(selector), provider);
return extHostLanguageFeatures.registerDocumentFormattingEditProvider(extension, checkSelector(selector), provider);
},
registerDocumentRangeFormattingEditProvider(selector: vscode.DocumentSelector, provider: vscode.DocumentRangeFormattingEditProvider): vscode.Disposable {
return extHostLanguageFeatures.registerDocumentRangeFormattingEditProvider(checkSelector(selector), provider);
return extHostLanguageFeatures.registerDocumentRangeFormattingEditProvider(extension, checkSelector(selector), provider);
},
registerOnTypeFormattingEditProvider(selector: vscode.DocumentSelector, provider: vscode.OnTypeFormattingEditProvider, firstTriggerCharacter: string, ...moreTriggerCharacters: string[]): vscode.Disposable {
return extHostLanguageFeatures.registerOnTypeFormattingEditProvider(checkSelector(selector), provider, [firstTriggerCharacter].concat(moreTriggerCharacters));
return extHostLanguageFeatures.registerOnTypeFormattingEditProvider(extension, checkSelector(selector), provider, [firstTriggerCharacter].concat(moreTriggerCharacters));
},
registerSignatureHelpProvider(selector: vscode.DocumentSelector, provider: vscode.SignatureHelpProvider, firstItem?: string | vscode.SignatureHelpProviderMetadata, ...remaining: string[]): vscode.Disposable {
if (typeof firstItem === 'object') {
return extHostLanguageFeatures.registerSignatureHelpProvider(checkSelector(selector), provider, firstItem);
return extHostLanguageFeatures.registerSignatureHelpProvider(extension, checkSelector(selector), provider, firstItem);
}
return extHostLanguageFeatures.registerSignatureHelpProvider(checkSelector(selector), provider, typeof firstItem === 'undefined' ? [] : [firstItem, ...remaining]);
return extHostLanguageFeatures.registerSignatureHelpProvider(extension, checkSelector(selector), provider, typeof firstItem === 'undefined' ? [] : [firstItem, ...remaining]);
},
registerCompletionItemProvider(selector: vscode.DocumentSelector, provider: vscode.CompletionItemProvider, ...triggerCharacters: string[]): vscode.Disposable {
return extHostLanguageFeatures.registerCompletionItemProvider(checkSelector(selector), provider, triggerCharacters);
return extHostLanguageFeatures.registerCompletionItemProvider(extension, checkSelector(selector), provider, triggerCharacters);
},
registerDocumentLinkProvider(selector: vscode.DocumentSelector, provider: vscode.DocumentLinkProvider): vscode.Disposable {
return extHostLanguageFeatures.registerDocumentLinkProvider(checkSelector(selector), provider);
return extHostLanguageFeatures.registerDocumentLinkProvider(extension, checkSelector(selector), provider);
},
registerColorProvider(selector: vscode.DocumentSelector, provider: vscode.DocumentColorProvider): vscode.Disposable {
return extHostLanguageFeatures.registerColorProvider(checkSelector(selector), provider);
return extHostLanguageFeatures.registerColorProvider(extension, checkSelector(selector), provider);
},
registerFoldingRangeProvider(selector: vscode.DocumentSelector, provider: vscode.FoldingRangeProvider): vscode.Disposable {
return extHostLanguageFeatures.registerFoldingRangeProvider(checkSelector(selector), provider);
return extHostLanguageFeatures.registerFoldingRangeProvider(extension, checkSelector(selector), provider);
},
setLanguageConfiguration: (language: string, configuration: vscode.LanguageConfiguration): vscode.Disposable => {
return extHostLanguageFeatures.setLanguageConfiguration(language, configuration);
@ -872,19 +891,3 @@ function defineAPI(factory: IExtensionApiFactory, extensionPaths: TernarySearchT
return defaultApiImpl;
};
}
const nullExtensionDescription: IExtensionDescription = {
id: 'nullExtensionDescription',
name: 'Null Extension Description',
publisher: 'vscode',
activationEvents: undefined,
contributes: undefined,
enableProposedApi: false,
engines: undefined,
extensionDependencies: undefined,
extensionLocation: undefined,
isBuiltin: false,
isUnderDevelopment: false,
main: undefined,
version: undefined
};

8
src/vs/workbench/api/node/extHost.protocol.ts
View file

@ -68,6 +68,7 @@ export interface IInitData {
telemetryInfo: ITelemetryInfo;
logLevel: LogLevel;
logsLocation: URI;
remoteAuthority?: string | null;
}
export interface IConfigurationInitData extends IConfigurationData {
@ -80,6 +81,7 @@ export interface IWorkspaceConfigurationChangeEventData {
}
export interface IExtHostContext extends IRPCProtocol {
remoteAuthority: string;
}
export interface IMainContext extends IRPCProtocol {
@ -591,11 +593,11 @@ export interface MainThreadDebugServiceShape extends IDisposable {
$acceptDAError(handle: number, name: string, message: string, stack: string): void;
$acceptDAExit(handle: number, code: number, signal: string): void;
$registerDebugConfigurationProvider(type: string, hasProvideMethod: boolean, hasResolveMethod: boolean, hasProvideDaMethod: boolean, hasProvideTrackerMethod: boolean, handle: number): Thenable<void>;
$unregisterDebugConfigurationProvider(handle: number): Thenable<void>;
$unregisterDebugConfigurationProvider(handle: number): void;
$startDebugging(folder: UriComponents | undefined, nameOrConfig: string | vscode.DebugConfiguration): Thenable<boolean>;
$customDebugAdapterRequest(id: DebugSessionUUID, command: string, args: any): Thenable<any>;
$appendDebugConsole(value: string): Thenable<void>;
$startBreakpointEvents(): Thenable<void>;
$appendDebugConsole(value: string): void;
$startBreakpointEvents(): void;
$registerBreakpoints(breakpoints: (ISourceMultiBreakpointDto | IFunctionBreakpointDto)[]): Thenable<void>;
$unregisterBreakpoints(breakpointIds: string[], functionBreakpointIds: string[]): Thenable<void>;
}

2
src/vs/workbench/api/node/extHostClipboard.ts
View file

@ -3,8 +3,6 @@
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
'use strict';
import { IMainContext, MainContext, MainThreadClipboardShape } from 'vs/workbench/api/node/extHost.protocol';
import * as vscode from 'vscode';

13
src/vs/workbench/api/node/extHostDebugService.ts
View file

@ -9,7 +9,6 @@ import { URI, UriComponents } from 'vs/base/common/uri';
import { Event, Emitter } from 'vs/base/common/event';
import { asThenable } from 'vs/base/common/async';
import * as nls from 'vs/nls';
import { deepClone } from 'vs/base/common/objects';
import {
MainContext, MainThreadDebugServiceShape, ExtHostDebugServiceShape, DebugSessionUUID,
IMainContext, IBreakpointsDeltaDto, ISourceMultiBreakpointDto, IFunctionBreakpointDto, IDebugSessionDto
@ -391,17 +390,14 @@ export class ExtHostDebugService implements ExtHostDebugServiceShape {
da.onMessage(message => {
// since we modify Source.paths in the message in place, we need to make a copy of it (see #61129)
const msg = deepClone(message);
if (tracker) {
tracker.fromDebugAdapter(msg);
tracker.fromDebugAdapter(message);
}
// DA -> VS Code
convertToVSCPaths(msg, source => stringToUri(source));
message = convertToVSCPaths(message, source => stringToUri(source));
mythis._debugServiceProxy.$acceptDAMessage(handle, msg);
mythis._debugServiceProxy.$acceptDAMessage(handle, message);
});
da.onError(err => {
if (tracker) {
@ -429,8 +425,9 @@ export class ExtHostDebugService implements ExtHostDebugServiceShape {
}
public $sendDAMessage(handle: number, message: DebugProtocol.ProtocolMessage): Promise<void> {
// VS Code -> DA
convertToDAPaths(message, source => uriToString(source));
message = convertToDAPaths(message, source => uriToString(source));
const tracker = this._debugAdaptersTrackers.get(handle);
if (tracker) {

18
src/vs/workbench/api/node/extHostFileSystem.ts
View file

@ -7,7 +7,7 @@ import { URI, UriComponents } from 'vs/base/common/uri';
import { MainContext, IMainContext, ExtHostFileSystemShape, MainThreadFileSystemShape, IFileChangeDto } from './extHost.protocol';
import * as vscode from 'vscode';
import * as files from 'vs/platform/files/common/files';
import { IDisposable, toDisposable } from 'vs/base/common/lifecycle';
import { IDisposable, toDisposable, dispose } from 'vs/base/common/lifecycle';
import { values } from 'vs/base/common/map';
import { Range, FileChangeType } from 'vs/workbench/api/node/extHostTypes';
import { ExtHostLanguageFeatures } from 'vs/workbench/api/node/extHostLanguageFeatures';
@ -64,9 +64,10 @@ export class ExtHostFileSystem implements ExtHostFileSystemShape {
private readonly _usedSchemes = new Set<string>();
private readonly _watches = new Map<number, IDisposable>();
private _linkProviderRegistration: IDisposable;
private _handlePool: number = 0;
constructor(mainContext: IMainContext, extHostLanguageFeatures: ExtHostLanguageFeatures) {
constructor(mainContext: IMainContext, private _extHostLanguageFeatures: ExtHostLanguageFeatures) {
this._proxy = mainContext.getProxy(MainContext.MainThreadFileSystem);
this._usedSchemes.add(Schemas.file);
this._usedSchemes.add(Schemas.untitled);
@ -77,8 +78,16 @@ export class ExtHostFileSystem implements ExtHostFileSystemShape {
this._usedSchemes.add(Schemas.https);
this._usedSchemes.add(Schemas.mailto);
this._usedSchemes.add(Schemas.data);
}
extHostLanguageFeatures.registerDocumentLinkProvider('*', this._linkProvider);
dispose(): void {
dispose(this._linkProviderRegistration);
}
private _registerLinkProviderIfNotYetRegistered(): void {
if (!this._linkProviderRegistration) {
this._linkProviderRegistration = this._extHostLanguageFeatures.registerDocumentLinkProvider(undefined, '*', this._linkProvider);
}
}
registerFileSystemProvider(scheme: string, provider: vscode.FileSystemProvider, options: { isCaseSensitive?: boolean, isReadonly?: boolean } = {}) {
@ -87,6 +96,9 @@ export class ExtHostFileSystem implements ExtHostFileSystemShape {
throw new Error(`a provider for the scheme '${scheme}' is already registered`);
}
//
this._registerLinkProviderIfNotYetRegistered();
const handle = this._handlePool++;
this._linkProvider.add(scheme);
this._usedSchemes.add(scheme);

109
src/vs/workbench/api/node/extHostLanguageFeatures.ts
View file

@ -842,6 +842,13 @@ type Adapter = OutlineAdapter | CodeLensAdapter | DefinitionAdapter | HoverAdapt
| SuggestAdapter | SignatureHelpAdapter | LinkProviderAdapter | ImplementationAdapter | TypeDefinitionAdapter
| ColorProviderAdapter | FoldingProviderAdapter;
class AdapterData {
constructor(
readonly adapter: Adapter,
readonly extension: IExtensionDescription | undefined
) { }
}
export interface ISchemeTransformer {
transformOutgoing(scheme: string): string;
}
@ -856,7 +863,7 @@ export class ExtHostLanguageFeatures implements ExtHostLanguageFeaturesShape {
private _commands: ExtHostCommands;
private _heapService: ExtHostHeapService;
private _diagnostics: ExtHostDiagnostics;
private _adapter = new Map<number, Adapter>();
private _adapter = new Map<number, AdapterData>();
private readonly _logService: ILogService;
constructor(
@ -925,23 +932,35 @@ export class ExtHostLanguageFeatures implements ExtHostLanguageFeaturesShape {
}
private _withAdapter<A, R>(handle: number, ctor: { new(...args: any[]): A }, callback: (adapter: A) => Thenable<R>): Thenable<R> {
let adapter = this._adapter.get(handle);
if (!(adapter instanceof ctor)) {
return Promise.reject(new Error('no adapter found'));
let data = this._adapter.get(handle);
if (data.adapter instanceof ctor) {
let t1: number;
if (data.extension) {
t1 = Date.now();
this._logService.trace(`[${data.extension.id}] INVOKE provider '${(ctor as any).name}'`);
}
let p = callback(data.adapter);
if (data.extension) {
Promise.resolve(p).then(
() => this._logService.trace(`[${data.extension.id}] provider DONE after ${Date.now() - t1}ms`),
err => this._logService.trace(`[${data.extension.id}] provider FAILED`, err)
);
}
return p;
}
return callback(<any>adapter);
return Promise.reject(new Error('no adapter found'));
}
private _addNewAdapter(adapter: Adapter): number {
private _addNewAdapter(adapter: Adapter, extension: IExtensionDescription): number {
const handle = this._nextHandle();
this._adapter.set(handle, adapter);
this._adapter.set(handle, new AdapterData(adapter, extension));
return handle;
}
// --- outline
registerDocumentSymbolProvider(selector: vscode.DocumentSelector, provider: vscode.DocumentSymbolProvider, extension?: IExtensionDescription): vscode.Disposable {
const handle = this._addNewAdapter(new OutlineAdapter(this._documents, provider));
registerDocumentSymbolProvider(extension: IExtensionDescription, selector: vscode.DocumentSelector, provider: vscode.DocumentSymbolProvider): vscode.Disposable {
const handle = this._addNewAdapter(new OutlineAdapter(this._documents, provider), extension);
this._proxy.$registerOutlineSupport(handle, this._transformDocumentSelector(selector), extension ? extension.displayName || extension.name : undefined);
return this._createDisposable(handle);
}
@ -952,11 +971,11 @@ export class ExtHostLanguageFeatures implements ExtHostLanguageFeaturesShape {
// --- code lens
registerCodeLensProvider(selector: vscode.DocumentSelector, provider: vscode.CodeLensProvider): vscode.Disposable {
registerCodeLensProvider(extension: IExtensionDescription, selector: vscode.DocumentSelector, provider: vscode.CodeLensProvider): vscode.Disposable {
const handle = this._nextHandle();
const eventHandle = typeof provider.onDidChangeCodeLenses === 'function' ? this._nextHandle() : undefined;
this._adapter.set(handle, new CodeLensAdapter(this._documents, this._commands.converter, this._heapService, provider));
this._adapter.set(handle, new AdapterData(new CodeLensAdapter(this._documents, this._commands.converter, this._heapService, provider), extension));
this._proxy.$registerCodeLensSupport(handle, this._transformDocumentSelector(selector), eventHandle);
let result = this._createDisposable(handle);
@ -978,8 +997,8 @@ export class ExtHostLanguageFeatures implements ExtHostLanguageFeaturesShape {
// --- declaration
registerDefinitionProvider(selector: vscode.DocumentSelector, provider: vscode.DefinitionProvider): vscode.Disposable {
const handle = this._addNewAdapter(new DefinitionAdapter(this._documents, provider));
registerDefinitionProvider(extension: IExtensionDescription, selector: vscode.DocumentSelector, provider: vscode.DefinitionProvider): vscode.Disposable {
const handle = this._addNewAdapter(new DefinitionAdapter(this._documents, provider), extension);
this._proxy.$registerDeclaractionSupport(handle, this._transformDocumentSelector(selector));
return this._createDisposable(handle);
}
@ -988,8 +1007,8 @@ export class ExtHostLanguageFeatures implements ExtHostLanguageFeaturesShape {
return this._withAdapter(handle, DefinitionAdapter, adapter => adapter.provideDefinition(URI.revive(resource), position, token));
}
registerImplementationProvider(selector: vscode.DocumentSelector, provider: vscode.ImplementationProvider): vscode.Disposable {
const handle = this._addNewAdapter(new ImplementationAdapter(this._documents, provider));
registerImplementationProvider(extension: IExtensionDescription, selector: vscode.DocumentSelector, provider: vscode.ImplementationProvider): vscode.Disposable {
const handle = this._addNewAdapter(new ImplementationAdapter(this._documents, provider), extension);
this._proxy.$registerImplementationSupport(handle, this._transformDocumentSelector(selector));
return this._createDisposable(handle);
}
@ -998,8 +1017,8 @@ export class ExtHostLanguageFeatures implements ExtHostLanguageFeaturesShape {
return this._withAdapter(handle, ImplementationAdapter, adapter => adapter.provideImplementation(URI.revive(resource), position, token));
}
registerTypeDefinitionProvider(selector: vscode.DocumentSelector, provider: vscode.TypeDefinitionProvider): vscode.Disposable {
const handle = this._addNewAdapter(new TypeDefinitionAdapter(this._documents, provider));
registerTypeDefinitionProvider(extension: IExtensionDescription, selector: vscode.DocumentSelector, provider: vscode.TypeDefinitionProvider): vscode.Disposable {
const handle = this._addNewAdapter(new TypeDefinitionAdapter(this._documents, provider), extension);
this._proxy.$registerTypeDefinitionSupport(handle, this._transformDocumentSelector(selector));
return this._createDisposable(handle);
}
@ -1010,8 +1029,8 @@ export class ExtHostLanguageFeatures implements ExtHostLanguageFeaturesShape {
// --- extra info
registerHoverProvider(selector: vscode.DocumentSelector, provider: vscode.HoverProvider, extensionId?: string): vscode.Disposable {
const handle = this._addNewAdapter(new HoverAdapter(this._documents, provider));
registerHoverProvider(extension: IExtensionDescription, selector: vscode.DocumentSelector, provider: vscode.HoverProvider, extensionId?: string): vscode.Disposable {
const handle = this._addNewAdapter(new HoverAdapter(this._documents, provider), extension);
this._proxy.$registerHoverProvider(handle, this._transformDocumentSelector(selector));
return this._createDisposable(handle);
}
@ -1022,8 +1041,8 @@ export class ExtHostLanguageFeatures implements ExtHostLanguageFeaturesShape {
// --- occurrences
registerDocumentHighlightProvider(selector: vscode.DocumentSelector, provider: vscode.DocumentHighlightProvider): vscode.Disposable {
const handle = this._addNewAdapter(new DocumentHighlightAdapter(this._documents, provider));
registerDocumentHighlightProvider(extension: IExtensionDescription, selector: vscode.DocumentSelector, provider: vscode.DocumentHighlightProvider): vscode.Disposable {
const handle = this._addNewAdapter(new DocumentHighlightAdapter(this._documents, provider), extension);
this._proxy.$registerDocumentHighlightProvider(handle, this._transformDocumentSelector(selector));
return this._createDisposable(handle);
}
@ -1034,8 +1053,8 @@ export class ExtHostLanguageFeatures implements ExtHostLanguageFeaturesShape {
// --- references
registerReferenceProvider(selector: vscode.DocumentSelector, provider: vscode.ReferenceProvider): vscode.Disposable {
const handle = this._addNewAdapter(new ReferenceAdapter(this._documents, provider));
registerReferenceProvider(extension: IExtensionDescription, selector: vscode.DocumentSelector, provider: vscode.ReferenceProvider): vscode.Disposable {
const handle = this._addNewAdapter(new ReferenceAdapter(this._documents, provider), extension);
this._proxy.$registerReferenceSupport(handle, this._transformDocumentSelector(selector));
return this._createDisposable(handle);
}
@ -1046,8 +1065,8 @@ export class ExtHostLanguageFeatures implements ExtHostLanguageFeaturesShape {
// --- quick fix
registerCodeActionProvider(selector: vscode.DocumentSelector, provider: vscode.CodeActionProvider, extension?: IExtensionDescription, metadata?: vscode.CodeActionProviderMetadata): vscode.Disposable {
const handle = this._addNewAdapter(new CodeActionAdapter(this._documents, this._commands.converter, this._diagnostics, provider, this._logService, extension ? extension.id : ''));
registerCodeActionProvider(extension: IExtensionDescription, selector: vscode.DocumentSelector, provider: vscode.CodeActionProvider, metadata?: vscode.CodeActionProviderMetadata): vscode.Disposable {
const handle = this._addNewAdapter(new CodeActionAdapter(this._documents, this._commands.converter, this._diagnostics, provider, this._logService, extension.id), extension);
this._proxy.$registerQuickFixSupport(handle, this._transformDocumentSelector(selector), metadata && metadata.providedCodeActionKinds ? metadata.providedCodeActionKinds.map(kind => kind.value) : undefined);
return this._createDisposable(handle);
}
@ -1059,8 +1078,8 @@ export class ExtHostLanguageFeatures implements ExtHostLanguageFeaturesShape {
// --- formatting
registerDocumentFormattingEditProvider(selector: vscode.DocumentSelector, provider: vscode.DocumentFormattingEditProvider): vscode.Disposable {
const handle = this._addNewAdapter(new DocumentFormattingAdapter(this._documents, provider));
registerDocumentFormattingEditProvider(extension: IExtensionDescription, selector: vscode.DocumentSelector, provider: vscode.DocumentFormattingEditProvider): vscode.Disposable {
const handle = this._addNewAdapter(new DocumentFormattingAdapter(this._documents, provider), extension);
this._proxy.$registerDocumentFormattingSupport(handle, this._transformDocumentSelector(selector));
return this._createDisposable(handle);
}
@ -1069,8 +1088,8 @@ export class ExtHostLanguageFeatures implements ExtHostLanguageFeaturesShape {
return this._withAdapter(handle, DocumentFormattingAdapter, adapter => adapter.provideDocumentFormattingEdits(URI.revive(resource), options, token));
}
registerDocumentRangeFormattingEditProvider(selector: vscode.DocumentSelector, provider: vscode.DocumentRangeFormattingEditProvider): vscode.Disposable {
const handle = this._addNewAdapter(new RangeFormattingAdapter(this._documents, provider));
registerDocumentRangeFormattingEditProvider(extension: IExtensionDescription, selector: vscode.DocumentSelector, provider: vscode.DocumentRangeFormattingEditProvider): vscode.Disposable {
const handle = this._addNewAdapter(new RangeFormattingAdapter(this._documents, provider), extension);
this._proxy.$registerRangeFormattingSupport(handle, this._transformDocumentSelector(selector));
return this._createDisposable(handle);
}
@ -1079,8 +1098,8 @@ export class ExtHostLanguageFeatures implements ExtHostLanguageFeaturesShape {
return this._withAdapter(handle, RangeFormattingAdapter, adapter => adapter.provideDocumentRangeFormattingEdits(URI.revive(resource), range, options, token));
}
registerOnTypeFormattingEditProvider(selector: vscode.DocumentSelector, provider: vscode.OnTypeFormattingEditProvider, triggerCharacters: string[]): vscode.Disposable {
const handle = this._addNewAdapter(new OnTypeFormattingAdapter(this._documents, provider));
registerOnTypeFormattingEditProvider(extension: IExtensionDescription, selector: vscode.DocumentSelector, provider: vscode.OnTypeFormattingEditProvider, triggerCharacters: string[]): vscode.Disposable {
const handle = this._addNewAdapter(new OnTypeFormattingAdapter(this._documents, provider), extension);
this._proxy.$registerOnTypeFormattingSupport(handle, this._transformDocumentSelector(selector), triggerCharacters);
return this._createDisposable(handle);
}
@ -1091,8 +1110,8 @@ export class ExtHostLanguageFeatures implements ExtHostLanguageFeaturesShape {
// --- navigate types
registerWorkspaceSymbolProvider(provider: vscode.WorkspaceSymbolProvider): vscode.Disposable {
const handle = this._addNewAdapter(new NavigateTypeAdapter(provider));
registerWorkspaceSymbolProvider(extension: IExtensionDescription, provider: vscode.WorkspaceSymbolProvider): vscode.Disposable {
const handle = this._addNewAdapter(new NavigateTypeAdapter(provider), extension);
this._proxy.$registerNavigateTypeSupport(handle);
return this._createDisposable(handle);
}
@ -1111,8 +1130,8 @@ export class ExtHostLanguageFeatures implements ExtHostLanguageFeaturesShape {
// --- rename
registerRenameProvider(selector: vscode.DocumentSelector, provider: vscode.RenameProvider): vscode.Disposable {
const handle = this._addNewAdapter(new RenameAdapter(this._documents, provider));
registerRenameProvider(extension: IExtensionDescription, selector: vscode.DocumentSelector, provider: vscode.RenameProvider): vscode.Disposable {
const handle = this._addNewAdapter(new RenameAdapter(this._documents, provider), extension);
this._proxy.$registerRenameSupport(handle, this._transformDocumentSelector(selector), RenameAdapter.supportsResolving(provider));
return this._createDisposable(handle);
}
@ -1127,8 +1146,8 @@ export class ExtHostLanguageFeatures implements ExtHostLanguageFeaturesShape {
// --- suggestion
registerCompletionItemProvider(selector: vscode.DocumentSelector, provider: vscode.CompletionItemProvider, triggerCharacters: string[]): vscode.Disposable {
const handle = this._addNewAdapter(new SuggestAdapter(this._documents, this._commands.converter, provider));
registerCompletionItemProvider(extension: IExtensionDescription, selector: vscode.DocumentSelector, provider: vscode.CompletionItemProvider, triggerCharacters: string[]): vscode.Disposable {
const handle = this._addNewAdapter(new SuggestAdapter(this._documents, this._commands.converter, provider), extension);
this._proxy.$registerSuggestSupport(handle, this._transformDocumentSelector(selector), triggerCharacters, SuggestAdapter.supportsResolving(provider));
return this._createDisposable(handle);
}
@ -1147,12 +1166,12 @@ export class ExtHostLanguageFeatures implements ExtHostLanguageFeaturesShape {
// --- parameter hints
registerSignatureHelpProvider(selector: vscode.DocumentSelector, provider: vscode.SignatureHelpProvider, metadataOrTriggerChars?: string[] | vscode.SignatureHelpProviderMetadata): vscode.Disposable {
registerSignatureHelpProvider(extension: IExtensionDescription, selector: vscode.DocumentSelector, provider: vscode.SignatureHelpProvider, metadataOrTriggerChars?: string[] | vscode.SignatureHelpProviderMetadata): vscode.Disposable {
const metadata: ISerializedSignatureHelpProviderMetadata = Array.isArray(metadataOrTriggerChars)
? { triggerCharacters: metadataOrTriggerChars, retriggerCharacters: [] }
: metadataOrTriggerChars;
const handle = this._addNewAdapter(new SignatureHelpAdapter(this._documents, provider));
const handle = this._addNewAdapter(new SignatureHelpAdapter(this._documents, provider), extension);
this._proxy.$registerSignatureHelpProvider(handle, this._transformDocumentSelector(selector), metadata);
return this._createDisposable(handle);
}
@ -1163,8 +1182,8 @@ export class ExtHostLanguageFeatures implements ExtHostLanguageFeaturesShape {
// --- links
registerDocumentLinkProvider(selector: vscode.DocumentSelector, provider: vscode.DocumentLinkProvider): vscode.Disposable {
const handle = this._addNewAdapter(new LinkProviderAdapter(this._documents, this._heapService, provider));
registerDocumentLinkProvider(extension: IExtensionDescription, selector: vscode.DocumentSelector, provider: vscode.DocumentLinkProvider): vscode.Disposable {
const handle = this._addNewAdapter(new LinkProviderAdapter(this._documents, this._heapService, provider), extension);
this._proxy.$registerDocumentLinkProvider(handle, this._transformDocumentSelector(selector));
return this._createDisposable(handle);
}
@ -1177,8 +1196,8 @@ export class ExtHostLanguageFeatures implements ExtHostLanguageFeaturesShape {
return this._withAdapter(handle, LinkProviderAdapter, adapter => adapter.resolveLink(link, token));
}
registerColorProvider(selector: vscode.DocumentSelector, provider: vscode.DocumentColorProvider): vscode.Disposable {
const handle = this._addNewAdapter(new ColorProviderAdapter(this._documents, provider));
registerColorProvider(extension: IExtensionDescription, selector: vscode.DocumentSelector, provider: vscode.DocumentColorProvider): vscode.Disposable {
const handle = this._addNewAdapter(new ColorProviderAdapter(this._documents, provider), extension);
this._proxy.$registerDocumentColorProvider(handle, this._transformDocumentSelector(selector));
return this._createDisposable(handle);
}
@ -1191,8 +1210,8 @@ export class ExtHostLanguageFeatures implements ExtHostLanguageFeaturesShape {
return this._withAdapter(handle, ColorProviderAdapter, adapter => adapter.provideColorPresentations(URI.revive(resource), colorInfo, token));
}
registerFoldingRangeProvider(selector: vscode.DocumentSelector, provider: vscode.FoldingRangeProvider): vscode.Disposable {
const handle = this._addNewAdapter(new FoldingProviderAdapter(this._documents, provider));
registerFoldingRangeProvider(extension: IExtensionDescription, selector: vscode.DocumentSelector, provider: vscode.FoldingRangeProvider): vscode.Disposable {
const handle = this._addNewAdapter(new FoldingProviderAdapter(this._documents, provider), extension);
this._proxy.$registerFoldingRangeProvider(handle, this._transformDocumentSelector(selector));
return this._createDisposable(handle);
}

27
src/vs/workbench/api/node/extHostSearch.fileIndex.ts
View file

@ -13,7 +13,6 @@ import * as resources from 'vs/base/common/resources';
import { StopWatch } from 'vs/base/common/stopwatch';
import * as strings from 'vs/base/common/strings';
import { URI } from 'vs/base/common/uri';
import { TPromise } from 'vs/base/common/winjs.base';
import { compareItemsByScore, IItemAccessor, prepareQuery, ScorerCache } from 'vs/base/parts/quickopen/common/quickOpenScorer';
import { ICachedSearchStats, IFileIndexProviderStats, IFileMatch, IFileQuery, IFileSearchStats, IFolderQuery, ISearchCompleteStats } from 'vs/platform/search/common/search';
import { IDirectoryEntry, IDirectoryTree, IInternalFileMatch } from 'vs/workbench/services/search/node/fileSearchManager';
@ -65,11 +64,11 @@ export class FileIndexSearchEngine {
this.activeCancellationTokens = new Set();
}
public search(_onResult: (match: IInternalFileMatch) => void): TPromise<{ isLimitHit: boolean, stats: IFileIndexProviderStats }> {
public search(_onResult: (match: IInternalFileMatch) => void): Promise<{ isLimitHit: boolean, stats: IFileIndexProviderStats }> {
// Searches a single folder
const folderQuery = this.config.folderQueries[0];
return new TPromise<{ isLimitHit: boolean, stats: IFileIndexProviderStats }>((resolve, reject) => {
return new Promise<{ isLimitHit: boolean, stats: IFileIndexProviderStats }>((resolve, reject) => {
const onResult = (match: IInternalFileMatch) => {
this.resultCount++;
_onResult(match);
@ -116,9 +115,9 @@ export class FileIndexSearchEngine {
});
}
private searchInFolder(fq: IFolderQuery<URI>, onResult: (match: IInternalFileMatch) => void): TPromise<IFileIndexProviderStats> {
private searchInFolder(fq: IFolderQuery<URI>, onResult: (match: IInternalFileMatch) => void): Promise<IFileIndexProviderStats> {
let cancellation = new CancellationTokenSource();
return new TPromise((resolve, reject) => {
return new Promise((resolve, reject) => {
const options = this.getSearchOptionsForFolder(fq);
const tree = this.initDirectoryTree();
@ -146,7 +145,7 @@ export class FileIndexSearchEngine {
let providerSW: StopWatch;
let providerTime: number;
let fileWalkTime: number;
new TPromise(resolve => process.nextTick(resolve))
new Promise(resolve => process.nextTick(resolve))
.then(() => {
this.activeCancellationTokens.add(cancellation);
providerSW = StopWatch.create();
@ -304,7 +303,7 @@ export class FileIndexSearchManager {
private readonly folderCacheKeys = new Map<string, Set<string>>();
public fileSearch(config: IFileQuery, provider: vscode.FileIndexProvider, onBatch: (matches: IFileMatch[]) => void, token: CancellationToken): TPromise<ISearchCompleteStats> {
public fileSearch(config: IFileQuery, provider: vscode.FileIndexProvider, onBatch: (matches: IFileMatch[]) => void, token: CancellationToken): Promise<ISearchCompleteStats> {
if (config.sortByScore) {
let sortedSearch = this.trySortedSearchFromCache(config, token);
if (!sortedSearch) {
@ -359,7 +358,7 @@ export class FileIndexSearchManager {
};
}
private doSortedSearch(engine: FileIndexSearchEngine, config: IFileQuery, token: CancellationToken): TPromise<IInternalSearchComplete> {
private doSortedSearch(engine: FileIndexSearchEngine, config: IFileQuery, token: CancellationToken): Promise<IInternalSearchComplete> {
let allResultsPromise = createCancelablePromise<IInternalSearchComplete<IFileIndexProviderStats>>(token => {
return this.doSearch(engine, token);
});
@ -413,7 +412,7 @@ export class FileIndexSearchManager {
return this.caches[cacheKey] = new Cache();
}
private trySortedSearchFromCache(config: IFileQuery, token: CancellationToken): TPromise<IInternalSearchComplete> {
private trySortedSearchFromCache(config: IFileQuery, token: CancellationToken): Promise<IInternalSearchComplete> {
const folderCacheKey = this.getFolderCacheKey(config);
const cache = folderCacheKey && this.caches[folderCacheKey];
if (!cache) {
@ -447,7 +446,7 @@ export class FileIndexSearchManager {
return undefined;
}
private sortResults(config: IFileQuery, results: IInternalFileMatch[], scorerCache: ScorerCache, token: CancellationToken): TPromise<IInternalFileMatch[]> {
private sortResults(config: IFileQuery, results: IInternalFileMatch[], scorerCache: ScorerCache, token: CancellationToken): Promise<IInternalFileMatch[]> {
// we use the same compare function that is used later when showing the results using fuzzy scoring
// this is very important because we are also limiting the number of results by config.maxResults
// and as such we want the top items to be included in this result set if the number of items
@ -469,7 +468,7 @@ export class FileIndexSearchManager {
}
}
private getResultsFromCache(cache: Cache, searchValue: string, token: CancellationToken): TPromise<IInternalSearchComplete<ICachedSearchStats>> {
private getResultsFromCache(cache: Cache, searchValue: string, token: CancellationToken): Promise<IInternalSearchComplete<ICachedSearchStats>> {
const cacheLookupSW = StopWatch.create();
if (path.isAbsolute(searchValue)) {
@ -503,7 +502,7 @@ export class FileIndexSearchManager {
const cacheLookupTime = cacheLookupSW.elapsed();
const cacheFilterSW = StopWatch.create();
return new TPromise<IInternalSearchComplete<ICachedSearchStats>>((c, e) => {
return new Promise<IInternalSearchComplete<ICachedSearchStats>>((c, e) => {
token.onCancellationRequested(() => e(canceled()));
cacheRow.promise.then(complete => {
@ -539,7 +538,7 @@ export class FileIndexSearchManager {
});
}
private doSearch(engine: FileIndexSearchEngine, token: CancellationToken): TPromise<IInternalSearchComplete<IFileIndexProviderStats>> {
private doSearch(engine: FileIndexSearchEngine, token: CancellationToken): Promise<IInternalSearchComplete<IFileIndexProviderStats>> {
token.onCancellationRequested(() => engine.cancel());
const results: IInternalFileMatch[] = [];
const onResult = match => results.push(match);
@ -553,7 +552,7 @@ export class FileIndexSearchManager {
});
}
public clearCache(cacheKey: string): TPromise<void> {
public clearCache(cacheKey: string): Promise<void> {
if (!this.folderCacheKeys.has(cacheKey)) {
return Promise.resolve(undefined);
}

2
src/vs/workbench/api/node/extHostTextEditor.ts
View file

@ -25,7 +25,7 @@ export class TextEditorDecorationType implements vscode.TextEditorDecorationType
constructor(proxy: MainThreadTextEditorsShape, options: vscode.DecorationRenderOptions) {
this.key = TextEditorDecorationType._Keys.nextId();
this._proxy = proxy;
this._proxy.$registerTextEditorDecorationType(this.key, <any>/* URI vs Uri */ options);
this._proxy.$registerTextEditorDecorationType(this.key, TypeConverters.DecorationRenderOptions.from(options));
}
public dispose(): void {

124
src/vs/workbench/api/node/extHostTypeConverters.ts
View file

@ -8,8 +8,8 @@ import * as types from './extHostTypes';
import * as search from 'vs/workbench/parts/search/common/search';
import { ITextEditorOptions } from 'vs/platform/editor/common/editor';
import { EditorViewColumn } from 'vs/workbench/api/shared/editor';
import { IDecorationOptions } from 'vs/editor/common/editorCommon';
import { EndOfLineSequence } from 'vs/editor/common/model';
import { IDecorationOptions, IThemeDecorationRenderOptions, IDecorationRenderOptions, IContentDecorationRenderOptions } from 'vs/editor/common/editorCommon';
import { EndOfLineSequence, TrackedRangeStickiness } from 'vs/editor/common/model';
import * as vscode from 'vscode';
import { URI } from 'vs/base/common/uri';
import { ProgressLocation as MainProgressLocation } from 'vs/platform/progress/common/progress';
@ -252,6 +252,126 @@ export function fromRangeOrRangeWithMessage(ranges: vscode.Range[] | vscode.Deco
}
}
function pathOrURIToURI(value: string | URI): URI {
if (typeof value === 'undefined') {
return value;
}
if (typeof value === 'string') {
return URI.file(value);
} else {
return value;
}
}
export namespace ThemableDecorationAttachmentRenderOptions {
export function from(options: vscode.ThemableDecorationAttachmentRenderOptions): IContentDecorationRenderOptions {
if (typeof options === 'undefined') {
return options;
}
return {
contentText: options.contentText,
contentIconPath: pathOrURIToURI(options.contentIconPath),
border: options.border,
borderColor: <string | types.ThemeColor>options.borderColor,
fontStyle: options.fontStyle,
fontWeight: options.fontWeight,
textDecoration: options.textDecoration,
color: <string | types.ThemeColor>options.color,
backgroundColor: <string | types.ThemeColor>options.backgroundColor,
margin: options.margin,
width: options.width,
height: options.height,
};
}
}
export namespace ThemableDecorationRenderOptions {
export function from(options: vscode.ThemableDecorationRenderOptions): IThemeDecorationRenderOptions {
if (typeof options === 'undefined') {
return options;
}
return {
backgroundColor: <string | types.ThemeColor>options.backgroundColor,
outline: options.outline,
outlineColor: <string | types.ThemeColor>options.outlineColor,
outlineStyle: options.outlineStyle,
outlineWidth: options.outlineWidth,
border: options.border,
borderColor: <string | types.ThemeColor>options.borderColor,
borderRadius: options.borderRadius,
borderSpacing: options.borderSpacing,
borderStyle: options.borderStyle,
borderWidth: options.borderWidth,
fontStyle: options.fontStyle,
fontWeight: options.fontWeight,
textDecoration: options.textDecoration,
cursor: options.cursor,
color: <string | types.ThemeColor>options.color,
opacity: options.opacity,
letterSpacing: options.letterSpacing,
gutterIconPath: pathOrURIToURI(options.gutterIconPath),
gutterIconSize: options.gutterIconSize,
overviewRulerColor: <string | types.ThemeColor>options.overviewRulerColor,
before: ThemableDecorationAttachmentRenderOptions.from(options.before),
after: ThemableDecorationAttachmentRenderOptions.from(options.after),
};
}
}
export namespace DecorationRangeBehavior {
export function from(value: types.DecorationRangeBehavior): TrackedRangeStickiness {
if (typeof value === 'undefined') {
return value;
}
switch (value) {
case types.DecorationRangeBehavior.OpenOpen:
return TrackedRangeStickiness.AlwaysGrowsWhenTypingAtEdges;
case types.DecorationRangeBehavior.ClosedClosed:
return TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges;
case types.DecorationRangeBehavior.OpenClosed:
return TrackedRangeStickiness.GrowsOnlyWhenTypingBefore;
case types.DecorationRangeBehavior.ClosedOpen:
return TrackedRangeStickiness.GrowsOnlyWhenTypingAfter;
}
}
}
export namespace DecorationRenderOptions {
export function from(options: vscode.DecorationRenderOptions): IDecorationRenderOptions {
return {
isWholeLine: options.isWholeLine,
rangeBehavior: DecorationRangeBehavior.from(options.rangeBehavior),
overviewRulerLane: options.overviewRulerLane,
light: ThemableDecorationRenderOptions.from(options.light),
dark: ThemableDecorationRenderOptions.from(options.dark),
backgroundColor: <string | types.ThemeColor>options.backgroundColor,
outline: options.outline,
outlineColor: <string | types.ThemeColor>options.outlineColor,
outlineStyle: options.outlineStyle,
outlineWidth: options.outlineWidth,
border: options.border,
borderColor: <string | types.ThemeColor>options.borderColor,
borderRadius: options.borderRadius,
borderSpacing: options.borderSpacing,
borderStyle: options.borderStyle,
borderWidth: options.borderWidth,
fontStyle: options.fontStyle,
fontWeight: options.fontWeight,
textDecoration: options.textDecoration,
cursor: options.cursor,
color: <string | types.ThemeColor>options.color,
opacity: options.opacity,
letterSpacing: options.letterSpacing,
gutterIconPath: pathOrURIToURI(options.gutterIconPath),
gutterIconSize: options.gutterIconSize,
overviewRulerColor: <string | types.ThemeColor>options.overviewRulerColor,
before: ThemableDecorationAttachmentRenderOptions.from(options.before),
after: ThemableDecorationAttachmentRenderOptions.from(options.after),
};
}
}
export namespace TextEdit {
export function from(edit: vscode.TextEdit): modes.TextEdit {

35
src/vs/workbench/api/node/extHostTypes.ts
View file

@ -48,9 +48,13 @@ export class Disposable {
export class Position {
static Min(...positions: Position[]): Position {
let result = positions.pop();
for (let p of positions) {
if (p.isBefore(result)) {
if (positions.length === 0) {
throw new TypeError();
}
let result = positions[0];
for (let i = 1; i < positions.length; i++) {
let p = positions[i];
if (p.isBefore(result!)) {
result = p;
}
}
@ -58,9 +62,13 @@ export class Position {
}
static Max(...positions: Position[]): Position {
let result = positions.pop();
for (let p of positions) {
if (p.isAfter(result)) {
if (positions.length === 0) {
throw new TypeError();
}
let result = positions[0];
for (let i = 1; i < positions.length; i++) {
let p = positions[i];
if (p.isAfter(result!)) {
result = p;
}
}
@ -579,9 +587,6 @@ export class WorkspaceEdit implements vscode.WorkspaceEdit {
res.push(candidate.edit);
}
}
if (res.length === 0) {
return undefined;
}
return res;
}
@ -811,7 +816,7 @@ export class Diagnostic {
};
}
static isEqual(a: Diagnostic, b: Diagnostic): boolean {
static isEqual(a: Diagnostic | undefined, b: Diagnostic | undefined): boolean {
if (a === b) {
return true;
}
@ -832,7 +837,7 @@ export class Diagnostic {
export class Hover {
public contents: vscode.MarkdownString[] | vscode.MarkedString[];
public range: Range;
public range: Range | undefined;
constructor(
contents: vscode.MarkdownString | vscode.MarkedString | vscode.MarkdownString[] | vscode.MarkedString[],
@ -916,7 +921,7 @@ export class SymbolInformation {
name: string;
location: Location;
kind: SymbolKind;
containerName: string;
containerName: string | undefined;
constructor(name: string, kind: SymbolKind, containerName: string, location: Location);
constructor(name: string, kind: SymbolKind, range: Range, uri?: URI, containerName?: string);
@ -1035,7 +1040,7 @@ export class CodeLens {
range: Range;
command: vscode.Command;
command: vscode.Command | undefined;
constructor(range: Range, command?: vscode.Command) {
this.range = range;
@ -1164,7 +1169,7 @@ export enum CompletionItemInsertTextRule {
export class CompletionItem implements vscode.CompletionItem {
label: string;
kind: CompletionItemKind;
kind: CompletionItemKind | undefined;
detail: string;
documentation: string | MarkdownString;
sortText: string;
@ -1186,7 +1191,7 @@ export class CompletionItem implements vscode.CompletionItem {
toJSON(): any {
return {
label: this.label,
kind: CompletionItemKind[this.kind],
kind: this.kind && CompletionItemKind[this.kind],
detail: this.detail,
documentation: this.documentation,
sortText: this.sortText,

9
src/vs/workbench/browser/actions.ts
View file

@ -3,7 +3,6 @@
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { TPromise } from 'vs/base/common/winjs.base';
import { Registry } from 'vs/platform/registry/common/platform';
import { Action, IAction } from 'vs/base/common/actions';
import { BaseActionItem, Separator } from 'vs/base/browser/ui/actionbar/actionbar';
@ -92,7 +91,7 @@ export class ContributableActionProvider implements IActionProvider {
return false;
}
getActions(tree: ITree, element: any): TPromise<IAction[]> {
getActions(tree: ITree, element: any): IAction[] {
const actions: IAction[] = [];
const context = this.toContext(tree, element);
@ -105,7 +104,7 @@ export class ContributableActionProvider implements IActionProvider {
}
}
return Promise.resolve(prepareActions(actions));
return prepareActions(actions);
}
hasSecondaryActions(tree: ITree, element: any): boolean {
@ -122,7 +121,7 @@ export class ContributableActionProvider implements IActionProvider {
return false;
}
getSecondaryActions(tree: ITree, element: any): TPromise<IAction[]> {
getSecondaryActions(tree: ITree, element: any): IAction[] {
const actions: IAction[] = [];
const context = this.toContext(tree, element);
@ -135,7 +134,7 @@ export class ContributableActionProvider implements IActionProvider {
}
}
return Promise.resolve(prepareActions(actions));
return prepareActions(actions);
}
getActionItem(tree: ITree, element: any, action: Action): BaseActionItem {

2
src/vs/workbench/browser/parts/activitybar/activitybarActions.ts
View file

@ -160,7 +160,7 @@ export class GlobalActivityActionItem extends ActivityActionItem {
this.contextMenuService.showContextMenu({
getAnchor: () => location,
getActions: () => Promise.resolve(actions),
getActions: () => actions,
onHide: () => dispose(actions)
});
}

2
src/vs/workbench/browser/parts/compositeBar.ts
View file

@ -401,7 +401,7 @@ export class CompositeBar extends Widget implements ICompositeBar {
const event = new StandardMouseEvent(e);
this.contextMenuService.showContextMenu({
getAnchor: () => { return { x: event.posx, y: event.posy }; },
getActions: () => Promise.resolve(this.getContextMenuActions())
getActions: () => this.getContextMenuActions()
});
}

4
src/vs/workbench/browser/parts/compositeBarActions.ts
View file

@ -373,7 +373,7 @@ export class CompositeOverflowActivityActionItem extends ActivityActionItem {
this.contextMenuService.showContextMenu({
getAnchor: () => this.element,
getActions: () => Promise.resolve(this.actions),
getActions: () => this.actions,
onHide: () => dispose(this.actions)
});
}
@ -598,7 +598,7 @@ export class CompositeActionItem extends ActivityActionItem {
this.contextMenuService.showContextMenu({
getAnchor: () => anchor,
getActionsContext: () => this.activity.id,
getActions: () => Promise.resolve(actions)
getActions: () => actions
});
}

2
src/vs/workbench/browser/parts/editor/editorGroupView.ts
View file

@ -308,7 +308,7 @@ export class EditorGroupView extends Themable implements IEditorGroupView {
// Show it
this.contextMenuService.showContextMenu({
getAnchor: () => anchor,
getActions: () => TPromise.as(actions),
getActions: () => actions,
onHide: () => this.focus()
});
}

2
src/vs/workbench/browser/parts/editor/resourceViewer.ts
View file

@ -284,7 +284,7 @@ class ZoomStatusbarItem extends Themable implements IStatusbarItem {
DOM.addDisposableListener(this.statusBarItem, DOM.EventType.CLICK, () => {
this.contextMenuService.showContextMenu({
getAnchor: () => container,
getActions: () => Promise.resolve(this.zoomActions)
getActions: () => this.zoomActions
});
});
}

2
src/vs/workbench/browser/parts/editor/titleControl.ts
View file

@ -288,7 +288,7 @@ export abstract class TitleControl extends Themable {
// Show it
this.contextMenuService.showContextMenu({
getAnchor: () => anchor,
getActions: () => Promise.resolve(actions),
getActions: () => actions,
getActionsContext: () => ({ groupId: this.group.id, editorIndex: this.group.getIndexOfEditor(editor) } as IEditorCommandsContext),
getKeyBinding: (action) => this.getKeybinding(action),
onHide: () => {

2
src/vs/workbench/browser/parts/notifications/notificationsList.ts
View file

@ -86,7 +86,7 @@ export class NotificationsList extends Themable {
this._register((this.list.onContextMenu(e => {
this.contextMenuService.showContextMenu({
getAnchor: () => e.anchor,
getActions: () => Promise.resolve([copyAction]),
getActions: () => [copyAction],
getActionsContext: () => e.element,
actionRunner
});

31
src/vs/workbench/browser/parts/quickinput/quickInput.ts
View file

@ -13,7 +13,6 @@ import { IThemeService } from 'vs/platform/theme/common/themeService';
import { contrastBorder, widgetShadow } from 'vs/platform/theme/common/colorRegistry';
import { SIDE_BAR_BACKGROUND, SIDE_BAR_FOREGROUND } from 'vs/workbench/common/theme';
import { IQuickOpenService } from 'vs/platform/quickOpen/common/quickOpen';
import { TPromise } from 'vs/base/common/winjs.base';
import { CancellationToken } from 'vs/base/common/cancellation';
import { QuickInputList } from './quickInputList';
import { QuickInputBox } from './quickInputBox';
@ -1041,8 +1040,8 @@ export class QuickInputService extends Component implements IQuickInputService {
this.updateStyles();
}
pick<T extends IQuickPickItem, O extends IPickOptions<T>>(picks: TPromise<QuickPickInput<T>[]> | QuickPickInput<T>[], options: O = <O>{}, token: CancellationToken = CancellationToken.None): TPromise<O extends { canPickMany: true } ? T[] : T> {
return new TPromise<O extends { canPickMany: true } ? T[] : T>((doResolve, reject) => {
pick<T extends IQuickPickItem, O extends IPickOptions<T>>(picks: Promise<QuickPickInput<T>[]> | QuickPickInput<T>[], options: O = <O>{}, token: CancellationToken = CancellationToken.None): Promise<O extends { canPickMany: true } ? T[] : T> {
return new Promise<O extends { canPickMany: true } ? T[] : T>((doResolve, reject) => {
let resolve = (result: any) => {
resolve = doResolve;
if (options.onKeyMods) {
@ -1117,7 +1116,7 @@ export class QuickInputService extends Component implements IQuickInputService {
input.quickNavigate = options.quickNavigate;
input.contextKey = options.contextKey;
input.busy = true;
TPromise.join([picks, options.activeItem])
Promise.all([picks, options.activeItem])
.then(([items, _activeItem]) => {
activeItem = _activeItem;
input.busy = false;
@ -1130,29 +1129,29 @@ export class QuickInputService extends Component implements IQuickInputService {
}
});
input.show();
TPromise.wrap(picks).then(null, err => {
Promise.resolve(picks).then(null, err => {
reject(err);
input.hide();
});
});
}
input(options: IInputOptions = {}, token: CancellationToken = CancellationToken.None): TPromise<string> {
return new TPromise<string>((resolve, reject) => {
input(options: IInputOptions = {}, token: CancellationToken = CancellationToken.None): Promise<string> {
return new Promise<string>((resolve, reject) => {
if (token.isCancellationRequested) {
resolve(undefined);
return;
}
const input = this.createInputBox();
const validateInput = options.validateInput || (() => TPromise.as(undefined));
const validateInput = options.validateInput || (() => <Thenable<undefined>>Promise.resolve(undefined));
const onDidValueChange = debounceEvent(input.onDidChangeValue, (last, cur) => cur, 100);
let validationValue = options.value || '';
let validation = TPromise.wrap(validateInput(validationValue));
let validation = Promise.resolve(validateInput(validationValue));
const disposables = [
input,
onDidValueChange(value => {
if (value !== validationValue) {
validation = TPromise.wrap(validateInput(value));
validation = Promise.resolve(validateInput(value));
validationValue = value;
}
validation.then(result => {
@ -1164,7 +1163,7 @@ export class QuickInputService extends Component implements IQuickInputService {
input.onDidAccept(() => {
const value = input.value;
if (value !== validationValue) {
validation = TPromise.wrap(validateInput(value));
validation = Promise.resolve(validateInput(value));
validationValue = value;
}
validation.then(result => {
@ -1335,17 +1334,17 @@ export class QuickInputService extends Component implements IQuickInputService {
accept() {
this.onDidAcceptEmitter.fire();
return TPromise.as(undefined);
return Promise.resolve(undefined);
}
back() {
this.onDidTriggerButtonEmitter.fire(this.backButton);
return TPromise.as(undefined);
return Promise.resolve(undefined);
}
cancel() {
this.hide();
return TPromise.as(undefined);
return Promise.resolve(undefined);
}
layout(dimension: dom.Dimension): void {
@ -1411,8 +1410,8 @@ export class BackAction extends Action {
super(id, label);
}
public run(): TPromise<any> {
public run(): Promise<any> {
this.quickInputService.back();
return TPromise.as(null);
return Promise.resolve(null);
}
}

23
src/vs/workbench/browser/parts/quickopen/quickOpenController.ts
View file

@ -4,7 +4,6 @@
*--------------------------------------------------------------------------------------------*/
import 'vs/css!./media/quickopen';
import { TPromise, ValueCallback } from 'vs/base/common/winjs.base';
import * as nls from 'vs/nls';
import * as browser from 'vs/base/browser/browser';
import * as strings from 'vs/base/common/strings';
@ -54,6 +53,8 @@ import { IStorageService } from 'vs/platform/storage/common/storage';
const HELP_PREFIX = '?';
type ValueCallback<T = any> = (value: T | Thenable<T>) => void;
export class QuickOpenController extends Component implements IQuickOpenService {
private static readonly MAX_SHORT_RESPONSE_TIME = 500;
@ -73,7 +74,7 @@ export class QuickOpenController extends Component implements IQuickOpenService
private lastSubmittedInputValue: string;
private quickOpenWidget: QuickOpenWidget;
private dimension: Dimension;
private mapResolvedHandlersToPrefix: { [prefix: string]: TPromise<QuickOpenHandler>; } = Object.create(null);
private mapResolvedHandlersToPrefix: { [prefix: string]: Promise<QuickOpenHandler>; } = Object.create(null);
private mapContextKeyToContext: { [id: string]: IContextKey<boolean>; } = Object.create(null);
private handlerOnOpenCalled: { [prefix: string]: boolean; } = Object.create(null);
private promisesToCompleteOnHide: ValueCallback[] = [];
@ -153,12 +154,12 @@ export class QuickOpenController extends Component implements IQuickOpenService
}
}
show(prefix?: string, options?: IShowOptions): TPromise<void> {
show(prefix?: string, options?: IShowOptions): Promise<void> {
let quickNavigateConfiguration = options ? options.quickNavigateConfiguration : void 0;
let inputSelection = options ? options.inputSelection : void 0;
let autoFocus = options ? options.autoFocus : void 0;
const promiseCompletedOnHide = new TPromise<void>(c => {
const promiseCompletedOnHide = new Promise<void>(c => {
this.promisesToCompleteOnHide.push(c);
});
@ -381,7 +382,7 @@ export class QuickOpenController extends Component implements IQuickOpenService
return;
}
let resultPromise: TPromise<void>;
let resultPromise: Promise<void>;
let resultPromiseDone = false;
if (handlerDescriptor) {
@ -426,7 +427,7 @@ export class QuickOpenController extends Component implements IQuickOpenService
});
}
private handleDefaultHandler(handler: QuickOpenHandlerDescriptor, value: string, token: CancellationToken): TPromise<void> {
private handleDefaultHandler(handler: QuickOpenHandlerDescriptor, value: string, token: CancellationToken): Promise<void> {
// Fill in history results if matching and we are configured to search in history
let matchingHistoryEntries: QuickOpenEntry[];
@ -514,7 +515,7 @@ export class QuickOpenController extends Component implements IQuickOpenService
}
}
private handleSpecificHandler(handlerDescriptor: QuickOpenHandlerDescriptor, value: string, token: CancellationToken): TPromise<void> {
private handleSpecificHandler(handlerDescriptor: QuickOpenHandlerDescriptor, value: string, token: CancellationToken): Promise<void> {
return this.resolveHandler(handlerDescriptor).then((resolvedHandler: QuickOpenHandler) => {
// Remove handler prefix from search value
@ -585,7 +586,7 @@ export class QuickOpenController extends Component implements IQuickOpenService
return mapEntryToPath;
}
private resolveHandler(handler: QuickOpenHandlerDescriptor): TPromise<QuickOpenHandler> {
private resolveHandler(handler: QuickOpenHandlerDescriptor): Promise<QuickOpenHandler> {
let result = this._resolveHandler(handler);
const id = handler.getId();
@ -603,11 +604,11 @@ export class QuickOpenController extends Component implements IQuickOpenService
return result.then<QuickOpenHandler>(null, (error) => {
delete this.mapResolvedHandlersToPrefix[id];
return TPromise.wrapError(new Error(`Unable to instantiate quick open handler ${handler.getId()}: ${JSON.stringify(error)}`));
return Promise.reject(new Error(`Unable to instantiate quick open handler ${handler.getId()}: ${JSON.stringify(error)}`));
});
}
private _resolveHandler(handler: QuickOpenHandlerDescriptor): TPromise<QuickOpenHandler> {
private _resolveHandler(handler: QuickOpenHandlerDescriptor): Promise<QuickOpenHandler> {
const id = handler.getId();
// Return Cached
@ -835,7 +836,7 @@ export class RemoveFromEditorHistoryAction extends Action {
super(id, label);
}
run(): TPromise<any> {
run(): Thenable<any> {
interface IHistoryPickEntry extends IQuickPickItem {
input: IEditorInput | IResourceInput;
}

2
src/vs/workbench/browser/parts/sidebar/sidebarPart.ts
View file

@ -170,7 +170,7 @@ export class SidebarPart extends CompositePart<Viewlet> {
const anchor: { x: number, y: number } = { x: event.posx, y: event.posy };
this.contextMenuService.showContextMenu({
getAnchor: () => anchor,
getActions: () => Promise.resolve(contextMenuActions),
getActions: () => contextMenuActions,
getActionItem: action => this.actionItemProvider(action as Action),
actionRunner: activeViewlet.getActionRunner()
});

2
src/vs/workbench/browser/parts/statusbar/statusbarPart.ts
View file

@ -288,7 +288,7 @@ class StatusBarEntryItem implements IStatusbarItem {
this.contextMenuService.showContextMenu({
getAnchor: () => el,
getActionsContext: () => this.entry.extensionId,
getActions: () => Promise.resolve([manageExtensionAction])
getActions: () => [manageExtensionAction]
});
}));
}

48
src/vs/workbench/browser/parts/titlebar/menubarControl.ts
View file

@ -15,7 +15,7 @@ import { ActionRunner, IActionRunner, IAction, Action } from 'vs/base/common/act
import { Separator } from 'vs/base/browser/ui/actionbar/actionbar';
import * as DOM from 'vs/base/browser/dom';
import { IKeybindingService } from 'vs/platform/keybinding/common/keybinding';
import { isMacintosh } from 'vs/base/common/platform';
import { isMacintosh, isLinux } from 'vs/base/common/platform';
import { Menu, IMenuOptions, SubmenuAction, MENU_MNEMONIC_REGEX, cleanMnemonic, MENU_ESCAPED_MNEMONIC_REGEX } from 'vs/base/browser/ui/menu/menu';
import { KeyCode, KeyCodeUtils } from 'vs/base/common/keyCodes';
import { StandardKeyboardEvent } from 'vs/base/browser/keyboardEvent';
@ -32,6 +32,9 @@ import { ILabelService } from 'vs/platform/label/common/label';
import { IUpdateService, StateType } from 'vs/platform/update/common/update';
import { Gesture, EventType, GestureEvent } from 'vs/base/browser/touch';
import { attachMenuStyler } from 'vs/platform/theme/common/styler';
import { IStorageService, StorageScope } from 'vs/platform/storage/common/storage';
import { INotificationService, Severity } from 'vs/platform/notification/common/notification';
import { IPreferencesService } from 'vs/workbench/services/preferences/common/preferences';
const $ = DOM.$;
@ -124,7 +127,10 @@ export class MenubarControl extends Disposable {
@IKeybindingService private keybindingService: IKeybindingService,
@IConfigurationService private configurationService: IConfigurationService,
@ILabelService private labelService: ILabelService,
@IUpdateService private updateService: IUpdateService
@IUpdateService private updateService: IUpdateService,
@IStorageService private storageService: IStorageService,
@INotificationService private notificationService: INotificationService,
@IPreferencesService private preferencesService: IPreferencesService
) {
super();
@ -167,6 +173,8 @@ export class MenubarControl extends Disposable {
this.recentlyOpened = recentlyOpened;
});
this.detectAndRecommendCustomTitlebar();
this.registerListeners();
}
@ -348,6 +356,7 @@ export class MenubarControl extends Disposable {
if (event.affectsConfiguration('window.menuBarVisibility')) {
this.setUnfocusedState();
this.detectAndRecommendCustomTitlebar();
}
}
@ -436,6 +445,41 @@ export class MenubarControl extends Disposable {
});
}
private detectAndRecommendCustomTitlebar(): void {
if (!isLinux) {
return;
}
if (!this.storageService.getBoolean('menubar/electronFixRecommended', StorageScope.GLOBAL, false)) {
if (this.currentMenubarVisibility === 'hidden' || this.currentTitlebarStyleSetting === 'custom') {
// Issue will not arise for user, abort notification
return;
}
const message = nls.localize('menubar.electronFixRecommendation', "If you experience hard to read text in the menu bar, we recommend trying out the custom title bar.");
this.notificationService.prompt(Severity.Info, message, [
{
label: nls.localize('goToSetting', "Open Settings"),
run: () => {
return this.preferencesService.openGlobalSettings(undefined, { query: 'window.titleBarStyle' });
}
},
{
label: nls.localize('moreInfo', "More Info"),
run: () => {
window.open('https://go.microsoft.com/fwlink/?linkid=2038566');
}
},
{
label: nls.localize('neverShowAgain', "Don't Show Again"),
run: () => {
this.storageService.store('menubar/electronFixRecommended', true, StorageScope.GLOBAL);
}
}
]);
}
}
private registerListeners(): void {
// Update when config changes
this._register(this.configurationService.onDidChangeConfiguration(e => this.onConfigurationUpdated(e)));

2
src/vs/workbench/browser/parts/titlebar/titlebarPart.ts
View file

@ -456,7 +456,7 @@ export class TitlebarPart extends Part implements ITitleService {
if (actions.length) {
this.contextMenuService.showContextMenu({
getAnchor: () => anchor,
getActions: () => Promise.resolve(actions),
getActions: () => actions,
onHide: () => actions.forEach(a => a.dispose())
});
}

Some files were not shown because too many files have changed in this diff Show more