rename empty view contents to view welcome

build/lib/i18n.resources.json

@@ -62,10 +62,6 @@
 			"name": "vs/workbench/contrib/debug",
 			"project": "vscode-workbench"
 		},
-		{
-			"name": "vs/workbench/contrib/documentation",
-			"project": "vscode-workbench"
-		},
 		{
 			"name": "vs/workbench/contrib/emmet",
 			"project": "vscode-workbench"

extensions/git/package.json

@@ -1762,35 +1762,33 @@
         ]
       }
     },
-    "documentation": {
-      "view": [
-        {
-          "view": "workbench.scm",
-          "contents": "%view.workbench.scm.disabled%",
-          "when": "!config.git.enabled"
-        },
-        {
-          "view": "workbench.scm",
-          "contents": "%view.workbench.scm.missing%",
-          "when": "config.git.enabled && git.missing"
-        },
-        {
-          "view": "workbench.scm",
-          "contents": "%view.workbench.scm.empty%",
-          "when": "config.git.enabled && !git.missing && workbenchState == empty"
-        },
-        {
-          "view": "workbench.scm",
-          "contents": "%view.workbench.scm.folder%",
-          "when": "config.git.enabled && !git.missing && workbenchState == folder"
-        },
-        {
-          "view": "workbench.scm",
-          "contents": "%view.workbench.scm.workspace%",
-          "when": "config.git.enabled && !git.missing && workbenchState == workspace"
-        }
-      ]
-    }
+    "viewsWelcome": [
+      {
+        "view": "workbench.scm",
+        "contents": "%view.workbench.scm.disabled%",
+        "when": "!config.git.enabled"
+      },
+      {
+        "view": "workbench.scm",
+        "contents": "%view.workbench.scm.missing%",
+        "when": "config.git.enabled && git.missing"
+      },
+      {
+        "view": "workbench.scm",
+        "contents": "%view.workbench.scm.empty%",
+        "when": "config.git.enabled && !git.missing && workbenchState == empty"
+      },
+      {
+        "view": "workbench.scm",
+        "contents": "%view.workbench.scm.folder%",
+        "when": "config.git.enabled && !git.missing && workbenchState == folder"
+      },
+      {
+        "view": "workbench.scm",
+        "contents": "%view.workbench.scm.workspace%",
+        "when": "config.git.enabled && !git.missing && workbenchState == workspace"
+      }
+    ]
   },
   "dependencies": {
     "byline": "^5.0.0",

src/vs/workbench/contrib/codeActions/common/codeActions.contribution.ts

@@ -10,9 +10,12 @@ import { Registry } from 'vs/platform/registry/common/platform';
 import { Extensions as WorkbenchExtensions, IWorkbenchContributionsRegistry } from 'vs/workbench/common/contributions';
 import { CodeActionsContribution, editorConfiguration } from 'vs/workbench/contrib/codeActions/common/codeActionsContribution';
 import { CodeActionsExtensionPoint, codeActionsExtensionPointDescriptor } from 'vs/workbench/contrib/codeActions/common/codeActionsExtensionPoint';
+import { CodeActionDocumentationContribution } from 'vs/workbench/contrib/codeActions/common/documentationContribution';
+import { DocumentationExtensionPoint, documentationExtensionPointDescriptor } from 'vs/workbench/contrib/codeActions/common/documentationExtensionPoint';
 import { ExtensionsRegistry } from 'vs/workbench/services/extensions/common/extensionsRegistry';
 
 const codeActionsExtensionPoint = ExtensionsRegistry.registerExtensionPoint<CodeActionsExtensionPoint[]>(codeActionsExtensionPointDescriptor);
+const documentationExtensionPoint = ExtensionsRegistry.registerExtensionPoint<DocumentationExtensionPoint>(documentationExtensionPointDescriptor);
 
 Registry.as<IConfigurationRegistry>(Extensions.Configuration)
 	.registerConfiguration(editorConfiguration);
@@ -22,6 +25,7 @@ class WorkbenchConfigurationContribution {
 		@IInstantiationService instantiationService: IInstantiationService,
 	) {
 		instantiationService.createInstance(CodeActionsContribution, codeActionsExtensionPoint);
+		instantiationService.createInstance(CodeActionDocumentationContribution, documentationExtensionPoint);
 	}
 }
 

src/vs/workbench/contrib/documentation/common/documentationContribution.ts → src/vs/workbench/contrib/codeActions/common/documentationContribution.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { CancellationToken } from 'vs/base/common/cancellation';
-import { Disposable, IDisposable } from 'vs/base/common/lifecycle';
+import { Disposable } from 'vs/base/common/lifecycle';
 import { Range } from 'vs/editor/common/core/range';
 import { Selection } from 'vs/editor/common/core/selection';
 import { ITextModel } from 'vs/editor/common/model';
@@ -13,24 +13,21 @@ import { CodeActionKind } from 'vs/editor/contrib/codeAction/types';
 import { ContextKeyExpr, IContextKeyService } from 'vs/platform/contextkey/common/contextkey';
 import { IWorkbenchContribution } from 'vs/workbench/common/contributions';
 import { IExtensionPoint } from 'vs/workbench/services/extensions/common/extensionsRegistry';
-import { DocumentationExtensionPoint, ViewDocumentationExtensionPoint } from './documentationExtensionPoint';
-import { Registry } from 'vs/platform/registry/common/platform';
-import { Extensions as ViewContainerExtensions, IViewsRegistry } from 'vs/workbench/common/views';
+import { DocumentationExtensionPoint } from './documentationExtensionPoint';
 
-interface ICodeActionContribution {
-	title: string;
-	when: ContextKeyExpr;
-	command: string;
-}
-
-const viewsRegistry = Registry.as<IViewsRegistry>(ViewContainerExtensions.ViewsRegistry);
 
-export class DocumentationContribution extends Disposable implements IWorkbenchContribution, modes.CodeActionProvider {
+export class CodeActionDocumentationContribution extends Disposable implements IWorkbenchContribution, modes.CodeActionProvider {
 
-	private codeActionContributions: ICodeActionContribution[] = [];
-	private readonly emptyCodeActionsList = { actions: [], dispose: () => { } };
+	private contributions: {
+		title: string;
+		when: ContextKeyExpr;
+		command: string;
+	}[] = [];
 
-	private emptyViewContents = new Map<ViewDocumentationExtensionPoint, IDisposable>();
+	private readonly emptyCodeActionsList = {
+		actions: [],
+		dispose: () => { }
+	};
 
 	constructor(
 		extensionPoint: IExtensionPoint<DocumentationExtensionPoint>,
@@ -40,46 +37,25 @@ export class DocumentationContribution extends Disposable implements IWorkbenchC
 
 		this._register(modes.CodeActionProviderRegistry.register('*', this));
 
-		extensionPoint.setHandler((points, { added, removed }) => {
+		extensionPoint.setHandler(points => {
+			this.contributions = [];
 			for (const documentation of points) {
-				if (documentation.value.refactoring) {
-					for (const contribution of documentation.value.refactoring) {
-						const precondition = ContextKeyExpr.deserialize(contribution.when);
-						if (!precondition) {
-							continue;
-						}
-
-						this.codeActionContributions.push({
-							title: contribution.title,
-							when: precondition,
-							command: contribution.command
-						});
-					}
+				if (!documentation.value.refactoring) {
+					continue;
 				}
-			}
 
-			for (const documentation of removed) {
-				if (documentation.value.view) {
-					for (const contribution of documentation.value.view) {
-						const disposable = this.emptyViewContents.get(contribution);
-
-						if (disposable) {
-							disposable.dispose();
-						}
+				for (const contribution of documentation.value.refactoring) {
+					const precondition = ContextKeyExpr.deserialize(contribution.when);
+					if (!precondition) {
+						continue;
 					}
-				}
-			}
 
-			for (const documentation of added) {
-				if (documentation.value.view) {
-					for (const contribution of documentation.value.view) {
-						const disposable = viewsRegistry.registerEmptyViewContent(contribution.view, {
-							content: contribution.contents,
-							when: ContextKeyExpr.deserialize(contribution.when)
-						});
+					this.contributions.push({
+						title: contribution.title,
+						when: precondition,
+						command: contribution.command
+					});
 
-						this.emptyViewContents.set(contribution, disposable);
-					}
 				}
 			}
 		});
@@ -96,7 +72,7 @@ export class DocumentationContribution extends Disposable implements IWorkbenchC
 			}
 		}
 
-		return this.codeActionContributions
+		return this.contributions
 			.filter(contribution => this.contextKeyService.contextMatchesRules(contribution.when))
 			.map(contribution => {
 				return {

src/vs/workbench/contrib/documentation/common/documentationExtensionPoint.ts → src/vs/workbench/contrib/codeActions/common/documentationExtensionPoint.ts

@@ -11,8 +11,6 @@ export enum DocumentationExtensionPointFields {
 	when = 'when',
 	title = 'title',
 	command = 'command',
-	view = 'view',
-	contents = 'contents',
 }
 
 export interface RefactoringDocumentationExtensionPoint {
@@ -21,15 +19,8 @@ export interface RefactoringDocumentationExtensionPoint {
 	readonly [DocumentationExtensionPointFields.command]: string;
 }
 
-export interface ViewDocumentationExtensionPoint {
-	readonly [DocumentationExtensionPointFields.view]: string;
-	readonly [DocumentationExtensionPointFields.contents]: string;
-	readonly [DocumentationExtensionPointFields.when]: string;
-}
-
 export interface DocumentationExtensionPoint {
 	readonly refactoring?: readonly RefactoringDocumentationExtensionPoint[];
-	readonly view?: readonly ViewDocumentationExtensionPoint[];
 }
 
 const documentationExtensionPointSchema = Object.freeze<IConfigurationPropertySchema>({
@@ -62,32 +53,6 @@ const documentationExtensionPointSchema = Object.freeze<IConfigurationPropertySc
 					},
 				},
 			}
-		},
-		'view': {
-			type: 'array',
-			description: nls.localize('contributes.documentation.views', "Contributed documentation for views."),
-			items: {
-				type: 'object',
-				description: nls.localize('contributes.documentation.view', "Contributed documentation for a view."),
-				required: [
-					DocumentationExtensionPointFields.view,
-					DocumentationExtensionPointFields.contents
-				],
-				properties: {
-					[DocumentationExtensionPointFields.view]: {
-						type: 'string',
-						description: nls.localize('contributes.documentation.view.view', "View identifier for this documentation."),
-					},
-					[DocumentationExtensionPointFields.contents]: {
-						type: 'string',
-						description: nls.localize('contributes.documentation.view.contents', "Documentation contents."),
-					},
-					[DocumentationExtensionPointFields.when]: {
-						type: 'string',
-						description: nls.localize('contributes.documentation.view.when', "When clause."),
-					},
-				},
-			}
 		}
 	}
 });

src/vs/workbench/contrib/documentation/common/documentation.contribution.ts → src/vs/workbench/contrib/welcome/common/viewsWelcome.contribution.ts

@@ -7,17 +7,17 @@ import { IInstantiationService } from 'vs/platform/instantiation/common/instanti
 import { LifecyclePhase } from 'vs/platform/lifecycle/common/lifecycle';
 import { Registry } from 'vs/platform/registry/common/platform';
 import { Extensions as WorkbenchExtensions, IWorkbenchContributionsRegistry } from 'vs/workbench/common/contributions';
-import { DocumentationContribution } from 'vs/workbench/contrib/documentation/common/documentationContribution';
-import { DocumentationExtensionPoint, documentationExtensionPointDescriptor } from 'vs/workbench/contrib/documentation/common/documentationExtensionPoint';
+import { ViewsWelcomeContribution } from 'vs/workbench/contrib/welcome/common/viewsWelcomeContribution';
+import { ViewsWelcomeExtensionPoint, viewsWelcomeExtensionPointDescriptor } from 'vs/workbench/contrib/welcome/common/viewsWelcomeExtensionPoint';
 import { ExtensionsRegistry } from 'vs/workbench/services/extensions/common/extensionsRegistry';
 
-const documentationExtensionPoint = ExtensionsRegistry.registerExtensionPoint<DocumentationExtensionPoint>(documentationExtensionPointDescriptor);
+const extensionPoint = ExtensionsRegistry.registerExtensionPoint<ViewsWelcomeExtensionPoint>(viewsWelcomeExtensionPointDescriptor);
 
 class WorkbenchConfigurationContribution {
 	constructor(
 		@IInstantiationService instantiationService: IInstantiationService,
 	) {
-		instantiationService.createInstance(DocumentationContribution, documentationExtensionPoint);
+		instantiationService.createInstance(ViewsWelcomeContribution, extensionPoint);
 	}
 }
 

src/vs/workbench/contrib/welcome/common/viewsWelcomeContribution.ts

+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Disposable, IDisposable } from 'vs/base/common/lifecycle';
+import { ContextKeyExpr } from 'vs/platform/contextkey/common/contextkey';
+import { IWorkbenchContribution } from 'vs/workbench/common/contributions';
+import { IExtensionPoint } from 'vs/workbench/services/extensions/common/extensionsRegistry';
+import { ViewsWelcomeExtensionPoint, ViewWelcome } from './viewsWelcomeExtensionPoint';
+import { Registry } from 'vs/platform/registry/common/platform';
+import { Extensions as ViewContainerExtensions, IViewsRegistry } from 'vs/workbench/common/views';
+
+const viewsRegistry = Registry.as<IViewsRegistry>(ViewContainerExtensions.ViewsRegistry);
+
+export class ViewsWelcomeContribution extends Disposable implements IWorkbenchContribution {
+
+	private viewWelcomeContents = new Map<ViewWelcome, IDisposable>();
+
+	constructor(extensionPoint: IExtensionPoint<ViewsWelcomeExtensionPoint>) {
+		super();
+
+		extensionPoint.setHandler((_, { added, removed }) => {
+			for (const contribution of removed) {
+				for (const welcome of contribution.value) {
+					const disposable = this.viewWelcomeContents.get(welcome);
+
+					if (disposable) {
+						disposable.dispose();
+					}
+				}
+			}
+
+			for (const contribution of added) {
+				for (const welcome of contribution.value) {
+					const disposable = viewsRegistry.registerEmptyViewContent(welcome.view, {
+						content: welcome.contents,
+						when: ContextKeyExpr.deserialize(welcome.when)
+					});
+
+					this.viewWelcomeContents.set(welcome, disposable);
+				}
+			}
+		});
+	}
+}

src/vs/workbench/contrib/welcome/common/viewsWelcomeExtensionPoint.ts

+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as nls from 'vs/nls';
+import { IConfigurationPropertySchema } from 'vs/platform/configuration/common/configurationRegistry';
+
+export enum ViewsWelcomeExtensionPointFields {
+	view = 'view',
+	contents = 'contents',
+	when = 'when',
+}
+
+export interface ViewWelcome {
+	readonly [ViewsWelcomeExtensionPointFields.view]: string;
+	readonly [ViewsWelcomeExtensionPointFields.contents]: string;
+	readonly [ViewsWelcomeExtensionPointFields.when]: string;
+}
+
+export type ViewsWelcomeExtensionPoint = ViewWelcome[];
+
+const viewsWelcomeExtensionPointSchema = Object.freeze<IConfigurationPropertySchema>({
+	type: 'array',
+	description: nls.localize('contributes.viewsWelcome', "Contributed views welcome content."),
+	items: {
+		type: 'object',
+		description: nls.localize('contributes.viewsWelcome.view', "Contributed welcome content for a specific view."),
+		required: [
+			ViewsWelcomeExtensionPointFields.view,
+			ViewsWelcomeExtensionPointFields.contents
+		],
+		properties: {
+			[ViewsWelcomeExtensionPointFields.view]: {
+				type: 'string',
+				description: nls.localize('contributes.viewsWelcome.view.view', "View identifier for this welcome content."),
+			},
+			[ViewsWelcomeExtensionPointFields.contents]: {
+				type: 'string',
+				description: nls.localize('contributes.viewsWelcome.view.contents', "Welcome content."),
+			},
+			[ViewsWelcomeExtensionPointFields.when]: {
+				type: 'string',
+				description: nls.localize('contributes.viewsWelcome.view.when', "When clause for this welcome content."),
+			},
+		}
+	}
+});
+
+export const viewsWelcomeExtensionPointDescriptor = {
+	extensionPoint: 'viewsWelcome',
+	jsonSchema: viewsWelcomeExtensionPointSchema
+};

src/vs/workbench/workbench.common.main.ts

@@ -272,8 +272,8 @@ import 'vs/workbench/contrib/userDataSync/browser/userDataSync.contribution';
 // Code Actions
 import 'vs/workbench/contrib/codeActions/common/codeActions.contribution';
 
-// Documentation
-import 'vs/workbench/contrib/documentation/common/documentation.contribution';
+// Welcome
+import 'vs/workbench/contrib/welcome/common/viewsWelcome.contribution';
 
 // Timeline
 import 'vs/workbench/contrib/timeline/browser/timeline.contribution';