instantiationService.ts ×21

Frontier kind: Code frontier

unlabeled · c_8ecdb6304a78

3053 tests · 7169 LOC · 36 files · introduces 0 tests · 109 LOC · 1 file

Introduces — evidence that enters the hierarchy at this concept

Code
21 ranges109 lines · 1 files
Tests
0 tests

Contains — complete concept membership

All code (extent)
1030 ranges7169 lines · 36 files · Browse complete extent
All tests (intent)
3053 testsBrowse complete intent

Neighbourhood graph

The orange circle is the focus. Violet and green circles are every ancestor and descendant, broader and narrower, at any distance; blue squares and pink diamonds are the introduced files and exact introduced tests of every visible concept, not only the focus's. Arrows point from broader to narrower concepts and bridge only concepts omitted from this view. Undirected links show source or test introduction. Concept and file size follows LOC; exact test nodes use test-count units.

Introduced files, introduced tests, and structurally relevant concept specialization

In the embedded map, ordinary wheel input scrolls the page; use the visible controls to zoom and drag to pan. Open the full-screen map for canvas navigation: wheel pans, Ctrl/Command plus wheel zooms, and arrow keys pan when this region is focused. On touch screens, open the full-screen map to pan or pinch. If JavaScript or WebGL is unavailable, use the native relationship evidence on this page.

Graph controls are ready.

Interactive rendering requires JavaScript and WebGL. Use the native relationship evidence on this page while the interactive map is unavailable.

Native relationship evidence

Every exact file and test below is linked only from the concept that introduces it.

Introduced tests

Every collected test enters the hierarchy at exactly one concept.

No tests are introduced at this concept. Its intent tests are introduced by other concepts.

Introduced code

Every collected source range enters the hierarchy at exactly one concept.

1 file ranked by introduced lines: 109 introduced LOC across 21 ranges. Expand a file to inspect source; the > gutter marks introduced lines.

src/vs/platform/instantiation/common/instantiationService.ts 109 introduced LOC · 21 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- instantiationService.ts
2 > * Copyright (c) Microsoft Corporation. All rights reserved.
3 > * Licensed under the MIT License. See License.txt in the project root for license information.
4 > *--------------------------------------------------------------------------------------------*/
5 >
6 > import { GlobalIdleValue } from '../../../base/common/async.js';
7 > import { Event } from '../../../base/common/event.js';
8 > import { illegalState } from '../../../base/common/errors.js';
9 > import { DisposableStore, dispose, IDisposable, isDisposable, toDisposable } from '../../../base/common/lifecycle.js';
10 > import { SyncDescriptor, SyncDescriptor0 } from './descriptors.js';
11 > import { Graph } from './graph.js';
12 > import { GetLeadingNonServiceArgs, IInstantiationService, ServiceIdentifier, ServicesAccessor, _util } from './instantiation.js';
13 > import { ServiceCollection } from './serviceCollection.js';
14 > import { LinkedList } from '../../../base/common/linkedList.js';
15 >
16 > // TRACING
17 > const _enableAllTracing = false
18 > // || "TRUE" // DO NOT CHECK IN!
19 > ;
20 >
21 > class CyclicDependencyError extends Error {
22 > constructor(graph: Graph<any>) {
23 super('cyclic dependency between services');
24 this.message = graph.findCycleSlow() ?? `UNABLE to detect cycle, dumping graph: \n${graph.toString()}`;
25 }
27 >
28 > export class InstantiationService implements IInstantiationService {
29 >
30 > declare readonly _serviceBrand: undefined;
31 >
32 > readonly _globalGraph?: Graph<string>;
33 > private _globalGraphImplicitDependency?: string;
34 >
35 > private _isDisposed = false;
36 > private readonly _servicesToMaybeDispose = new Set<any>();
37 > private readonly _children = new Set<InstantiationService>();
38 >
39 > constructor(
40 private readonly _services: ServiceCollection = new ServiceCollection(),
41 private readonly _strict: boolean = false,
47 this._globalGraph = _enableTracing ? _parent?._globalGraph ?? new Graph(e => e) : undefined;
48 }
50 > dispose(): void {
51 if (!this._isDisposed) {
52 this._isDisposed = true;
64 }
65 }
67 > private _throwIfDisposed(): void {
68 if (this._isDisposed) {
69 throw new Error('InstantiationService has been disposed');
70 }
71 }
73 > createChild(services: ServiceCollection, store?: DisposableStore): IInstantiationService {
74 this._throwIfDisposed();
75
86 return result;
87 }
89 > invokeFunction<R, TS extends any[] = []>(fn: (accessor: ServicesAccessor, ...args: TS) => R, ...args: TS): R {
90 this._throwIfDisposed();
91
113 }
114 }
116 > createInstance<T>(descriptor: SyncDescriptor0<T>): T;
117 > createInstance<Ctor extends new (...args: any[]) => unknown, R extends InstanceType<Ctor>>(ctor: Ctor, ...args: GetLeadingNonServiceArgs<ConstructorParameters<Ctor>>): R;
118 > createInstance(ctorOrDescriptor: any | SyncDescriptor<any>, ...rest: unknown[]): unknown {
119 this._throwIfDisposed();
120
131 return result;
132 }
134 > private _createInstance<T>(ctor: any, args: unknown[] = [], _trace: Trace): T {
135
136 // arguments defined by service decorators
162 return Reflect.construct<any, T>(ctor, args.concat(serviceArgs));
163 }
165 > private _setCreatedServiceInstance<T>(id: ServiceIdentifier<T>, instance: T): void {
166 if (this._services.get(id) instanceof SyncDescriptor) {
167 this._services.set(id, instance);
172 }
173 }
175 > private _getServiceInstanceOrDescriptor<T>(id: ServiceIdentifier<T>): T | SyncDescriptor<T> {
176 const instanceOrDesc = this._services.get(id);
177 if (!instanceOrDesc && this._parent) {
181 }
182 }
184 > protected _getOrCreateServiceInstance<T>(id: ServiceIdentifier<T>, _trace: Trace): T {
185 if (this._globalGraph && this._globalGraphImplicitDependency) {
186 this._globalGraph.insertEdge(this._globalGraphImplicitDependency, String(id));
194 }
195 }
197 > private readonly _activeInstantiations = new Set<ServiceIdentifier<any>>();
198 >
199 >
200 > private _safeCreateAndCacheServiceInstance<T>(id: ServiceIdentifier<T>, desc: SyncDescriptor<T>, _trace: Trace): T {
201 if (this._activeInstantiations.has(id)) {
202 throw new Error(`illegal state - RECURSIVELY instantiating service '${id}'`);
209 }
210 }
212 > private _createAndCacheServiceInstance<T>(id: ServiceIdentifier<T>, desc: SyncDescriptor<T>, _trace: Trace): T {
213
214 type Triple = { id: ServiceIdentifier<any>; desc: SyncDescriptor<any>; _trace: Trace };
279 return <T>this._getServiceInstanceOrDescriptor(id);
280 }
282 > private _createServiceInstanceWithOwner<T>(id: ServiceIdentifier<T>, ctor: any, args: unknown[] = [], supportsDelayedInstantiation: boolean, _trace: Trace): T {
283 if (this._services.get(id) instanceof SyncDescriptor) {
284 return this._createServiceInstance(id, ctor, args, supportsDelayedInstantiation, _trace, this._servicesToMaybeDispose);
289 }
290 }
292 > private _createServiceInstance<T>(id: ServiceIdentifier<T>, ctor: any, args: unknown[] = [], supportsDelayedInstantiation: boolean, _trace: Trace, disposeBucket: Set<any>): T {
293 if (!supportsDelayedInstantiation) {
294 // eager instantiation
384 }
385 }
387 > private _throwIfStrict(msg: string, printWarning: boolean): void {
388 if (printWarning) {
389 console.warn(msg);
393 }
394 }
396 >
397 > //#region -- tracing ---
398 >
399 > const enum TraceType {
400 > None = 0,
401 > Creation = 1,
402 > Invocation = 2,
403 > Branch = 3,
404 > }
405 >
406 > export class Trace {
407 >
408 > static all = new Set<string>();
409 >
410 > private static readonly _None = new class extends Trace {
411 > constructor() { super(TraceType.None, null); }
412 > override stop() { }
413 > override branch() { return this; }
414 > };
415 >
416 > static traceInvocation(_enableTracing: boolean, ctor: any): Trace {
417 return !_enableTracing ? Trace._None : new Trace(TraceType.Invocation, ctor.name || new Error().stack!.split('\n').slice(3, 4).join('\n'));
418 }
420 > static traceCreation(_enableTracing: boolean, ctor: any): Trace {
421 return !_enableTracing ? Trace._None : new Trace(TraceType.Creation, ctor.name);
422 }
424 > private static _totals: number = 0;
425 > private readonly _start: number = Date.now();
426 > private readonly _dep: [ServiceIdentifier<any>, boolean, Trace?][] = [];
427 >
428 > private constructor(
429 > readonly type: TraceType,
430 > readonly name: string | null
431 > ) { }
432 >
433 > branch(id: ServiceIdentifier<any>, first: boolean): Trace {
434 const child = new Trace(TraceType.Branch, id.toString());
435 this._dep.push([id, first, child]);
436 return child;
437 }
439 > stop() {
440 const dur = Date.now() - this._start;
441 Trace._totals += dur;