code: function (options) {
        if (this._booted) {
          return this;
        }
  
        options = new BootOptions(options);
  
        var registry = this.__registry__;
  
        registry.register('-environment:main', options.toEnvironment(), { instantiate: false });
        registry.injection('view', '_environment', '-environment:main');
        registry.injection('route', '_environment', '-environment:main');
  
        registry.register('service:-document', options.document, { instantiate: false });
  
        if (options.isInteractive) {
          registry.injection('view', 'renderer', 'renderer:-dom');
          registry.injection('component', 'renderer', 'renderer:-dom');
        } else {
          registry.injection('view', 'renderer', 'renderer:-inert');
          registry.injection('component', 'renderer', 'renderer:-inert');
        }
  
        if (options.rootElement) {
          this.rootElement = options.rootElement;
        } else {
          this.rootElement = this.application.rootElement;
        }
  
        if (options.location) {
          var router = _emberMetalProperty_get.get(this, 'router');
          _emberMetalProperty_set.set(router, 'location', options.location);
        }
  
        this.application.runInstanceInitializers(this);
  
        if (options.isInteractive) {
          this.setupEventDispatcher();
        }
  
        this._booted = true;
  
        return this;
      }
docs: Unfortunately, a lot of existing code assumes booting an instance is
  synchronous – specifically, a lot of tests assumes the last call to
  `app.advanceReadiness()` or `app.reset()` will result in a new instance
  being fully-booted when the current runloop completes.
  We would like new code (like the `visit` API) to stop making this assumption,
  so we created the asynchronous version above that returns a promise. But until
  we have migrated all the code, we would have to expose this method for use
  internally* in places where we need to boot an instance synchronously.
  @private