vscode 源码解析 - 依赖注入

export class CodeApplication extends Disposable {
  constructor(
    private readonly mainIpcServer: Server,
    private readonly userEnv: IProcessEnvironment,
    @IInstantiationService
    private readonly instantiationService: IInstantiationService,
    @ILogService private readonly logService: ILogService,
    @IEnvironmentService
    private readonly environmentService: IEnvironmentService,
    @ILifecycleMainService
    private readonly lifecycleMainService: ILifecycleMainService,
    @IConfigurationService
    private readonly configurationService: IConfigurationService,
    @IStateService private readonly stateService: IStateService
  ) {
    // ...
  }
}

await instantiationService.invokeFunction(async (accessor) => {
  // ...
 
  // 进行实例化，可以看到除了要被构造的类 CodeApplication 之外
  // 剩下参数的数目和 constructor 中未被装饰的参数的数目一致
  return instantiationService
    .createInstance(CodeApplication, mainIpcServer, instanceEnvironment)
    .startup()
})

export const IInstantiationService = createDecorator<IInstantiationService>(
  'instantiationService'
)

export function createDecorator<T>(serviceId: string): ServiceIdentifier<T> {
  // 装饰器会被缓存
  if (_util.serviceIds.has(serviceId)) {
    return _util.serviceIds.get(serviceId)!
  }
 
  // 装饰器
  const id = <any>function (target: Function, key: string, index: number): any {
    if (arguments.length !== 3) {
      throw new Error(
        '@IServiceName-decorator can only be used to decorate a parameter'
      )
    }
    storeServiceDependency(id, target, index, false)
  }
 
  id.toString = () => serviceId
 
  _util.serviceIds.set(serviceId, id)
  return id
}
 
function storeServiceDependency(
  id: Function,
  target: Function,
  index: number,
  optional: boolean
): void {
  // 在被装饰的类上记录一个依赖项
  if ((target as any)[_util.DI_TARGET] === target) {
    ;(target as any)[_util.DI_DEPENDENCIES].push({ id, index, optional })
  } else {
    ;(target as any)[_util.DI_DEPENDENCIES] = [{ id, index, optional }]
    ;(target as any)[_util.DI_TARGET] = target
  }
}

	private _createInstance<T>(ctor: any, args: any[] = [], _trace: Trace): T {
 
		// arguments defined by service decorators
		let serviceDependencies = _util.getServiceDependencies(ctor).sort((a, b) => a.index - b.index);
		let serviceArgs: any[] = [];
		for (const dependency of serviceDependencies) {
			let service = this._getOrCreateServiceInstance(dependency.id, _trace);
			if (!service && this._strict && !dependency.optional) {
				throw new Error(`[createInstance] ${ctor.name} depends on UNKNOWN service ${dependency.id}.`);
			}
			serviceArgs.push(service);
		}
 
		let firstServiceArgPos = serviceDependencies.length > 0 ? serviceDependencies[0].index : args.length;
 
		// check for argument mismatches, adjust static args if needed
		if (args.length !== firstServiceArgPos) {
			console.warn(`[createInstance] First service dependency of ${ctor.name} at position ${
				firstServiceArgPos + 1} conflicts with ${args.length} static arguments`);
 
			let delta = firstServiceArgPos - args.length;
			if (delta > 0) {
				args = args.concat(new Array(delta));
			} else {
				args = args.slice(0, firstServiceArgPos);
			}
		}
 
		// now create the instance
		return <T>new ctor(...[...args, ...serviceArgs]);
	}

services.set(ILifecycleMainService, new SyncDescriptor(LifecycleMainService))

	private _createAndCacheServiceInstance<T>(id: ServiceIdentifier<T>, desc: SyncDescriptor<T>, _trace: Trace): T {
		type Triple = { id: ServiceIdentifier<any>, desc: SyncDescriptor<any>, _trace: Trace };
		const graph = new Graph<Triple>(data => data.id.toString());
 
		let cycleCount = 0;
		const stack = [{ id, desc, _trace }];
		while (stack.length) {
			const item = stack.pop()!;
			graph.lookupOrInsertNode(item);
 
			// a weak but working heuristic for cycle checks
			if (cycleCount++ > 150) {
				throw new CyclicDependencyError(graph);
			}
 
			// check all dependencies for existence and if they need to be created first
			for (let dependency of _util.getServiceDependencies(item.desc.ctor)) {
 
				let instanceOrDesc = this._getServiceInstanceOrDescriptor(dependency.id);
				if (!instanceOrDesc && !dependency.optional) {
					console.warn(`[createInstance] ${id} depends on ${dependency.id} which is NOT registered.`);
				}
 
				if (instanceOrDesc instanceof SyncDescriptor) {
					const d = { id: dependency.id, desc: instanceOrDesc, _trace: item._trace.branch(dependency.id, true) };
					graph.insertEdge(item, d);
					stack.push(d);
				}
			}
		}
 
		while (true) {
			const roots = graph.roots();
 
			// if there is no more roots but still
			// nodes in the graph we have a cycle
			if (roots.length === 0) {
				if (!graph.isEmpty()) {
					throw new CyclicDependencyError(graph);
				}
				break;
			}
 
			for (const { data } of roots) {
				// create instance and overwrite the service collections
				const instance = this._createServiceInstanceWithOwner(data.id, data.desc.ctor, data.desc.staticArguments, data.desc.supportsDelayedInstantiation, data._trace);
				this._setServiceInstance(data.id, instance);
				graph.removeNode(data);
			}
		}
 
		return <T>this._getServiceInstanceOrDescriptor(id);
	}

registerSingleton(ILifecycleService, BrowserLifecycleService)

const _registry: [ServiceIdentifier<any>, SyncDescriptor<any>][] = []
 
export function registerSingleton<T, Services extends BrandedService[]>(
  id: ServiceIdentifier<T>,
  ctor: { new (...services: Services): T },
  supportsDelayedInstantiation?: boolean
): void {
  _registry.push([
    id,
    new SyncDescriptor<T>(ctor, [], supportsDelayedInstantiation)
  ])
}
 
export function getSingletonServiceDescriptors(): [
  ServiceIdentifier<any>,
  SyncDescriptor<any>
][] {
  return _registry
}

export function optional<T>(serviceIdentifier: ServiceIdentifier<T>) {
  return function (target: Function, key: string, index: number) {
    if (arguments.length !== 3) {
      throw new Error(
        '@optional-decorator can only be used to decorate a parameter'
      )
    }
    storeServiceDependency(serviceIdentifier, target, index, true)
  }
}

registerSingleton(IExtensionGalleryService, ExtensionGalleryService, true)

		} else {
			// Return a proxy object that's backed by an idle value. That
			// strategy is to instantiate services in our idle time or when actually
			// needed but not when injected into a consumer
			const idle = new IdleValue<any>(() => this._createInstance<T>(ctor, args, _trace));
			return <T>new Proxy(Object.create(null), {
				get(target: any, key: PropertyKey): any {
					if (key in target) {
						return target[key];
					}
					let obj = idle.getValue();
					let prop = obj[key];
					if (typeof prop !== 'function') {
						return prop;
					}
					prop = prop.bind(obj);
					target[key] = prop;
					return prop;
				},
				set(_target: T, p: PropertyKey, value: any): boolean {
					idle.getValue()[p] = value;
					return true;
				}
			});
		}
	}