fix(di): register zero-parameter arrow factories without annotate()

register(name, fn) sent every function through the legacy provider
kind, whose annotate() regex-parses the function source. An arrow
factory has no parameters to resolve and cannot be constructed, so it
now registers as a plain factory provider with identical call
semantics. Command dispatchers and other new-path registrations no
longer depend on annotate().

Author: edusperoni

lib/common/yok.ts

@@ -475,6 +475,18 @@ export class Yok extends Injector implements IInjector {
 
 		shared = shared === undefined ? true : shared;
 		if (_.isFunction(resolver)) {
+			if (resolver.length === 0 && !resolver.prototype) {
+				// A prototype-less zero-parameter function (an arrow factory) cannot
+				// be `new`ed and has no parameters to resolve, so annotate() would
+				// contribute nothing — register it as a plain factory.
+				super.register({
+					provide: nameOrProviders,
+					useFactory: <() => any>resolver,
+					shared,
+				});
+				return;
+			}
+
 			// Classes and factory functions alike: the legacy provider kind
 			// annotate()s the resolver and calls or news it by casing.
 			super.register({

test/command-registration.ts

@@ -59,4 +59,25 @@ describe("yok: command registration", () => {
 			]);
 		});
 	});
+
+	describe("register with a zero-parameter arrow factory", () => {
+		it("resolves by calling the factory, without annotate()", () => {
+			const factory = () => ({ value: 42 });
+			injector.register("arrowFactoryService", factory);
+
+			const instance = injector.resolve("arrowFactoryService");
+
+			assert.strictEqual(instance.value, 42);
+			assert.isUndefined((<any>factory).$inject);
+		});
+
+		it("stays shared by default", () => {
+			injector.register("sharedArrowFactoryService", () => ({}));
+
+			assert.strictEqual(
+				injector.resolve("sharedArrowFactoryService"),
+				injector.resolve("sharedArrowFactoryService"),
+			);
+		});
+	});
 });