title: What are the implications of "awaiting" for a synchronous function/method
body: <p>Let's say I have the following TypeScript implementation:</p>
  <pre class="lang-js prettyprint-override"><code>interface SomeInterface {
    bar(): Promise&lt;string&gt; | string
  }
  
  class SynchronousImplementation implements SomeInterface {
    bar(): string {
      return 'Hello Sync!'
    }
  }
  
  class AsynchronousImplementation implements SomeInterface {
    bar(): Promise&lt;string&gt; {
      return Promise.resolve('Hello Async!')
    }
  }
  
  class ConcreteClass {
    constructor(
      private readonly implementation: SomeInterface
    ) {}
  
    foo() {
      return this.implementation.bar()
    }
  }
  
  (async () =&gt; {
    const asynchronousImplementationInstance = new AsynchronousImplementation()
    const synchronousImplementationInstance = new SynchronousImplementation()
    const someConcreteClassInstance = new ConcreteClass(asynchronousImplementationInstance)
    const anotherConcreteClassInstance = new ConcreteClass(synchronousImplementationInstance)
  
    const someResult = await someConcreteClassInstance.foo()
    const anotherResult = await anotherConcreteClassInstance.foo()
  })()
  </code></pre>
  <p>Is there any undesired implicit consequences of &quot;awaiting&quot; for a function that in practice is synchronous, such as <code>await anotherConcreteClassInstance.foo()</code>, in terms of performance, memory usage, event loop or anything related to runtime?</p>