Fix regular sync functions into async

src/generator-to-promise.ts

@@ -32,10 +32,17 @@ export default function generatorToPromise<T>(
 	generatorFunction: any
 ): (...args: any[]) => Promise<T> {
 	if (!isGen(generatorFunction)) {
+		if (typeof generatorFunction === 'function') {
+			return function(this: any) {
+				return Promise.resolve(true).then(() =>
+					generatorFunction.call(this, arguments)
+				);
+			};
+		}
 		throw new Error('The given function must be a generator function');
 	}
 
-	return function invoker(this: any) {
+	return function(this: any) {
 		const deferred = createDeferred<T>();
 		const generator = generatorFunction.call(this, arguments);
 		(function next(error?: Error | null, value?: any) {

src/index.ts

@@ -163,14 +163,23 @@ namespace degenerator {
 			options.sandbox,
 			options
 		);
-		if (supportsAsync) {
+		if (typeof fn !== 'function') {
+			throw new Error(
+				`Expected a function to be returned, but got ${typeof fn}`
+			);
+		}
+		if (isAsyncFunction(fn)) {
 			return fn as T;
 		} else {
 			return (generatorToPromise(fn) as unknown) as T;
 		}
 	}
 }
 
+function isAsyncFunction(fn: any): boolean {
+	return typeof fn === 'function' && fn.constructor.name === 'AsyncFunction';
+}
+
 /**
  * Returns `true` if `node` has a matching name to one of the entries in the
  * `names` array.

test/test.ts

@@ -133,5 +133,37 @@ describe('degenerator()', () => {
 				done();
 			}, done);
 		});
+		it('should be able to compile functions with no async', done => {
+			const a = () => 'a';
+			const b = () => 'b';
+			function aPlusB(): string {
+				return a() + b();
+			}
+			const fn = compile<() => Promise<string>>(
+				'' + aPlusB,
+				'aPlusB',
+				[],
+				{
+					sandbox: { a, b }
+				}
+			);
+			fn().then((val: string) => {
+				assert.equal(val, 'ab');
+				done();
+			}, done);
+		});
+		it('should throw an Error if no function is returned from the `vm`', () => {
+			let err;
+			try {
+				compile<() => Promise<string>>('const foo = 1', 'foo', []);
+			} catch (_err) {
+				err = _err;
+			}
+			assert(err);
+			assert.equal(
+				err.message,
+				'Expected a function to be returned, but got number'
+			);
+		});
 	});
 });