Fix types due to owner.lookup type changes

We explicitly added `| undefined` to the return type in the previous commit

Co-authored-by: Robert Jackson <[email protected]>

packages/@ember/-internals/glimmer/lib/component-managers/curly.ts

@@ -119,27 +119,28 @@ export default class CurlyComponentManager
     };
   }
 
-  templateFor(component: Component): OwnedTemplate {
-    let { layout: _layout, layoutName } = component;
+  protected templateFor(component: Component): OwnedTemplate {
+    let { layout, layoutName } = component;
     let owner = getOwner(component);
 
-    let layout: TemplateFactory;
+    let factory: TemplateFactory;
 
-    if (_layout === undefined) {
+    if (layout === undefined) {
       if (layoutName !== undefined) {
-        layout = owner.lookup<TemplateFactory>(`template:${layoutName}`);
-        assert(`Layout \`${layoutName}\` not found!`, layout !== undefined);
+        let _factory = owner.lookup<TemplateFactory>(`template:${layoutName}`);
+        assert(`Layout \`${layoutName}\` not found!`, _factory !== undefined);
+        factory = _factory!;
       } else {
-        layout = owner.lookup(DEFAULT_LAYOUT);
+        factory = owner.lookup<TemplateFactory>(DEFAULT_LAYOUT)!;
       }
-    } else if (isTemplateFactory(_layout)) {
-      layout = _layout;
+    } else if (isTemplateFactory(layout)) {
+      factory = layout;
     } else {
       // we were provided an instance already
-      return _layout;
+      return layout;
     }
 
-    return layout(owner);
+    return factory(owner);
   }
 
   getDynamicLayout({ component }: ComponentStateBucket): Invocation {

packages/@ember/-internals/routing/lib/location/auto_location.ts

@@ -99,12 +99,11 @@ export default class AutoLocation extends EmberObject implements EmberLocation {
       implementation = 'none';
     }
 
-    let concrete = getOwner(this).lookup(`location:${implementation}`);
-    set(concrete, 'rootURL', rootURL);
+    let concrete = getOwner(this).lookup<EmberLocation>(`location:${implementation}`);
+    assert(`Could not find location '${implementation}'.`, concrete !== undefined);
 
-    assert(`Could not find location '${implementation}'.`, Boolean(concrete));
-
-    set(this, 'concreteImplementation', concrete);
+    set(concrete!, 'rootURL', rootURL);
+    set(this, 'concreteImplementation', concrete!);
   }
 
   willDestroy() {

packages/@ember/-internals/routing/lib/system/generate_controller.ts

@@ -1,5 +1,6 @@
 import { get } from '@ember/-internals/metal';
 import { Factory, Owner } from '@ember/-internals/owner';
+import Controller from '@ember/controller';
 import { info } from '@ember/debug';
 import { DEBUG } from '@glimmer/env';
 /**
@@ -39,11 +40,11 @@ export function generateControllerFactory(owner: Owner, controllerName: string):
   @private
   @since 1.3.0
 */
-export default function generateController(owner: Owner, controllerName: string) {
+export default function generateController(owner: Owner, controllerName: string): Controller {
   generateControllerFactory(owner, controllerName);
 
   let fullName = `controller:${controllerName}`;
-  let instance = owner.lookup(fullName);
+  let instance = owner.lookup<Controller>(fullName)!;
 
   if (DEBUG) {
     if (get(instance, 'namespace.LOG_ACTIVE_GENERATION')) {

packages/@ember/-internals/routing/lib/system/route.ts

@@ -18,6 +18,7 @@ import {
   typeOf,
 } from '@ember/-internals/runtime';
 import { EMBER_FRAMEWORK_OBJECT_OWNER_ARGUMENT } from '@ember/canary-features';
+import Controller from '@ember/controller';
 import { assert, deprecate, info, isTesting } from '@ember/debug';
 import { ROUTER_EVENTS } from '@ember/deprecated-features';
 import { assign } from '@ember/polyfills';
@@ -235,9 +236,9 @@ class Route extends EmberObject implements IRoute {
     @public
   */
   paramsFor(name: string) {
-    let route: Route = getOwner(this).lookup(`route:${name}`);
+    let route = getOwner(this).lookup<Route>(`route:${name}`);
 
-    if (!route) {
+    if (route === undefined) {
       return {};
     }
 
@@ -1272,7 +1273,7 @@ class Route extends EmberObject implements IRoute {
     @since 1.0.0
     @public
   */
-  setupController(controller: any, context: {}, _transition: Transition) {
+  setupController(controller: Controller, context: {}, _transition: Transition) {
     // eslint-disable-line no-unused-vars
     if (controller && context !== undefined) {
       set(controller, 'model', context);
@@ -1303,26 +1304,25 @@ class Route extends EmberObject implements IRoute {
     @since 1.0.0
     @public
   */
-  controllerFor(name: string, _skipAssert: boolean) {
+  controllerFor(name: string, _skipAssert: boolean): Controller {
     let owner = getOwner(this);
-    let route: Route = owner.lookup(`route:${name}`);
-    let controller: string;
+    let route = owner.lookup<Route>(`route:${name}`);
 
     if (route && route.controllerName) {
       name = route.controllerName;
     }
 
-    controller = owner.lookup(`controller:${name}`);
+    let controller = owner.lookup<Controller>(`controller:${name}`);
 
     // NOTE: We're specifically checking that skipAssert is true, because according
     //   to the old API the second parameter was model. We do not want people who
     //   passed a model to skip the assertion.
     assert(
       `The controller named '${name}' could not be found. Make sure that this route exists and has already been entered at least once. If you are accessing a controller not associated with a route, make sure the controller class is explicitly defined.`,
-      Boolean(controller) || _skipAssert === true
+      controller !== undefined || _skipAssert === true
     );
 
-    return controller;
+    return controller!;
   }
 
   /**
@@ -1408,7 +1408,7 @@ class Route extends EmberObject implements IRoute {
       name = _name;
     }
 
-    let route: Route = owner.lookup(`route:${name}`);
+    let route = owner.lookup<Route>(`route:${name}`);
     // If we are mid-transition, we want to try and look up
     // resolved parent contexts on the current transitionEvent.
     if (transition !== undefined && transition !== null) {
@@ -1812,7 +1812,9 @@ function buildRenderOptions(
   );
 
   let owner = getOwner(route);
-  let name, templateName, into, outlet, controller: string | {}, model;
+  let name, templateName, into, outlet, model;
+  let controller: Controller | string | undefined = undefined;
+
   if (options) {
     into = options.into && options.into.replace(/\//g, '.');
     outlet = options.outlet;
@@ -1829,31 +1831,32 @@ function buildRenderOptions(
     templateName = name;
   }
 
-  if (!controller!) {
+  if (controller === undefined) {
     if (isDefaultRender) {
-      controller = route.controllerName || owner.lookup(`controller:${name}`);
+      controller = route.controllerName || owner.lookup<Controller>(`controller:${name}`);
     } else {
-      controller = owner.lookup(`controller:${name}`) || route.controllerName || route.routeName;
+      controller =
+        owner.lookup<Controller>(`controller:${name}`) || route.controllerName || route.routeName;
     }
   }
 
-  if (typeof controller! === 'string') {
-    let controllerName = controller!;
-    controller = owner.lookup(`controller:${controllerName}`);
+  if (typeof controller === 'string') {
+    let controllerName = controller;
+    controller = owner.lookup<Controller>(`controller:${controllerName}`);
     assert(
       `You passed \`controller: '${controllerName}'\` into the \`render\` method, but no such controller could be found.`,
-      isDefaultRender || Boolean(controller)
+      isDefaultRender || controller !== undefined
     );
   }
 
   if (model) {
     (controller! as any).set('model', model);
   }
 
-  let template: TemplateFactory = owner.lookup(`template:${templateName}`);
+  let template = owner.lookup<TemplateFactory>(`template:${templateName}`);
   assert(
     `Could not find "${templateName}" template, view, or component.`,
-    isDefaultRender || Boolean(template)
+    isDefaultRender || template !== undefined
   );
 
   let parent: any;
@@ -1866,7 +1869,7 @@ function buildRenderOptions(
     into,
     outlet,
     name,
-    controller: controller! as any,
+    controller,
     template: template !== undefined ? template(owner) : route._topLevelViewTemplate(owner),
   };
 
@@ -2228,11 +2231,15 @@ Route.reopen(ActionHandler, Evented, {
 
     let controllerName = this.controllerName || this.routeName;
     let owner = getOwner(this);
-    let controller = owner.lookup(`controller:${controllerName}`);
+    let _controller = owner.lookup<Controller>(`controller:${controllerName}`);
     let queryParameterConfiguraton = get(this, 'queryParams');
     let hasRouterDefinedQueryParams = Object.keys(queryParameterConfiguraton).length > 0;
 
-    if (controller) {
+    let controller: Controller;
+
+    if (_controller) {
+      controller = _controller;
+
       // the developer has authored a controller class in their application for
       // this route find its query params and normalize their object shape them
       // merge in the query params for the route. As a mergedProperty,
@@ -2251,6 +2258,9 @@ Route.reopen(ActionHandler, Evented, {
       // Generate a class for them so we can later insert default values
       controller = generateController(owner, controllerName);
       combinedQueryParameterConfiguration = queryParameterConfiguraton;
+    } else {
+      assert(`Cannot find controller ${controllerName}`);
+      controller = 'unreachable' as any; // to keep TS happy
     }
 
     let qps = [];

packages/@ember/-internals/routing/lib/system/router.ts

@@ -150,7 +150,7 @@ class EmberRouter extends EmberObject {
     let seen = Object.create(null);
 
     class PrivateRouter extends Router<Route> {
-      getRoute(name: string) {
+      getRoute(name: string): Route {
         let routeName = name;
         let routeOwner = owner;
         let engineInfo = router._engineInfoByRoute[routeName];
@@ -164,10 +164,10 @@ class EmberRouter extends EmberObject {
 
         let fullRouteName = `route:${routeName}`;
 
-        let route: Route = routeOwner.lookup(fullRouteName);
+        let route = routeOwner.lookup<Route>(fullRouteName);
 
         if (seen[name]) {
-          return route;
+          return route!;
         }
 
         seen[name] = true;
@@ -184,15 +184,15 @@ class EmberRouter extends EmberObject {
           }
         }
 
-        route._setRouteName(routeName);
+        route!._setRouteName(routeName);
 
-        if (engineInfo && !hasDefaultSerialize(route)) {
+        if (engineInfo && !hasDefaultSerialize(route!)) {
           throw new Error(
             'Defining a custom serialize method on an Engine route is not supported.'
           );
         }
 
-        return route;
+        return route!;
       }
 
       getSerializer(name: string) {

packages/@ember/controller/index.d.ts

@@ -0,0 +1,8 @@
+export default interface Controller {
+  isController: true;
+  target?: unknown;
+  store?: unknown;
+  model?: unknown;
+}
+
+export function inject(name?: string): Controller;