@@ -14,10 +14,11 @@ import {LoadedRouterConfig, Route, Routes} from './config';
 import {CanLoadFn} from './interfaces';
 import {prioritizedGuardValue} from './operators/prioritized_guard_value';
 import {RouterConfigLoader} from './router_config_loader';
-import {defaultUrlMatcher, navigationCancelingError, Params, PRIMARY_OUTLET} from './shared';
+import {navigationCancelingError, Params, PRIMARY_OUTLET} from './shared';
 import {UrlSegment, UrlSegmentGroup, UrlSerializer, UrlTree} from './url_tree';
 import {forEach, waitForMap, wrapIntoObservable} from './utils/collection';
 import {getOutlet, groupRoutesByOutlet} from './utils/config';
+import {match, noLeftoversInUrl, split} from './utils/config_matching';
 import {isCanLoad, isFunction, isUrlTree} from './utils/type_guards';
 
 class NoMatch {
@@ -79,9 +80,10 @@ class ApplyRedirects {
   apply(): Observable<UrlTree> {
     const expanded$ =
         this.expandSegmentGroup(this.ngModule, this.config, this.urlTree.root, PRIMARY_OUTLET);
-    const urlTrees$ = expanded$.pipe(
-        map((rootSegmentGroup: UrlSegmentGroup) => this.createUrlTree(
-                rootSegmentGroup, this.urlTree.queryParams, this.urlTree.fragment!)));
+    const urlTrees$ = expanded$.pipe(map((rootSegmentGroup: UrlSegmentGroup) => {
+      return this.createUrlTree(
+          squashSegmentGroup(rootSegmentGroup), this.urlTree.queryParams, this.urlTree.fragment!);
+    }));
     return urlTrees$.pipe(catchError((e: any) => {
       if (e instanceof AbsoluteRedirect) {
         // after an absolute redirect we do not apply any more redirects!
@@ -101,9 +103,10 @@ class ApplyRedirects {
   private match(tree: UrlTree): Observable<UrlTree> {
     const expanded$ =
         this.expandSegmentGroup(this.ngModule, this.config, tree.root, PRIMARY_OUTLET);
-    const mapped$ = expanded$.pipe(
-        map((rootSegmentGroup: UrlSegmentGroup) =>
-                this.createUrlTree(rootSegmentGroup, tree.queryParams, tree.fragment!)));
+    const mapped$ = expanded$.pipe(map((rootSegmentGroup: UrlSegmentGroup) => {
+      return this.createUrlTree(
+          squashSegmentGroup(rootSegmentGroup), tree.queryParams, tree.fragment!);
+    }));
     return mapped$.pipe(catchError((e: any): Observable<UrlTree> => {
       if (e instanceof NoMatch) {
         throw this.noMatchError(e);
@@ -172,7 +175,7 @@ class ApplyRedirects {
           first((s: UrlSegmentGroup|null): s is UrlSegmentGroup => s !== null),
           catchError(e => {
             if (e instanceof EmptyError || e.name === 'EmptyError') {
-              if (this.noLeftoversInUrl(segmentGroup, segments, outlet)) {
+              if (noLeftoversInUrl(segmentGroup, segments, outlet)) {
                 return of(new UrlSegmentGroup([], {}));
               }
               throw new NoMatch(segmentGroup);
@@ -197,11 +200,6 @@ class ApplyRedirects {
         );
   }
 
-  private noLeftoversInUrl(segmentGroup: UrlSegmentGroup, segments: UrlSegment[], outlet: string):
-      boolean {
-    return segments.length === 0 && !segmentGroup.children[outlet];
-  }
-
   private expandSegmentAgainstRoute(
       ngModule: NgModuleRef<any>, segmentGroup: UrlSegmentGroup, routes: Route[], route: Route,
       paths: UrlSegment[], outlet: string, allowRedirects: boolean): Observable<UrlSegmentGroup> {
@@ -256,8 +254,8 @@ class ApplyRedirects {
         match(segmentGroup, route, segments);
     if (!matched) return noMatch(segmentGroup);
 
-    const newTree = this.applyRedirectCommands(
-        consumedSegments, route.redirectTo!, <any>positionalParamSegments);
+    const newTree =
+        this.applyRedirectCommands(consumedSegments, route.redirectTo!, positionalParamSegments);
     if (route.redirectTo!.startsWith('/')) {
       return absoluteRedirect(newTree);
     }
@@ -296,6 +294,14 @@ class ApplyRedirects {
 
       const {segmentGroup, slicedSegments} =
           split(rawSegmentGroup, consumedSegments, rawSlicedSegments, childConfig);
+      // TODO(atscott): clearing the source segment and segment index shift is only necessary to
+      // prevent failures in tests which assert exact object matches. The `split` is now shared
+      // between applyRedirects and recognize and only the `recognize` step needs these properties.
+      // Before the implementations were merged, the applyRedirects would not assign them.
+      // We should be able to remove this logic as a "breaking change" but should do some more
+      // investigation into the failures first.
+      segmentGroup._sourceSegment = undefined;
+      segmentGroup._segmentIndexShift = undefined;
 
       if (slicedSegments.length === 0 && segmentGroup.hasChildren()) {
         const expanded$ = this.expandChildren(childModule, childConfig, segmentGroup);
@@ -467,64 +473,15 @@ class ApplyRedirects {
   }
 }
 
-function match(segmentGroup: UrlSegmentGroup, route: Route, segments: UrlSegment[]): {
-  matched: boolean,
-  consumedSegments: UrlSegment[],
-  lastChild: number,
-  positionalParamSegments: {[k: string]: UrlSegment}
-} {
-  if (route.path === '') {
-    if ((route.pathMatch === 'full') && (segmentGroup.hasChildren() || segments.length > 0)) {
-      return {matched: false, consumedSegments: [], lastChild: 0, positionalParamSegments: {}};
-    }
-
-    return {matched: true, consumedSegments: [], lastChild: 0, positionalParamSegments: {}};
-  }
-
-  const matcher = route.matcher || defaultUrlMatcher;
-  const res = matcher(segments, segmentGroup, route);
-
-  if (!res) {
-    return {
-      matched: false,
-      consumedSegments: <any[]>[],
-      lastChild: 0,
-      positionalParamSegments: {},
-    };
-  }
-
-  return {
-    matched: true,
-    consumedSegments: res.consumed!,
-    lastChild: res.consumed.length!,
-    positionalParamSegments: res.posParams!,
-  };
-}
-
-function split(
-    segmentGroup: UrlSegmentGroup, consumedSegments: UrlSegment[], slicedSegments: UrlSegment[],
-    config: Route[]) {
-  if (slicedSegments.length > 0 &&
-      containsEmptyPathRedirectsWithNamedOutlets(segmentGroup, slicedSegments, config)) {
-    const s = new UrlSegmentGroup(
-        consumedSegments,
-        createChildrenForEmptySegments(
-            config, new UrlSegmentGroup(slicedSegments, segmentGroup.children)));
-    return {segmentGroup: mergeTrivialChildren(s), slicedSegments: []};
-  }
-
-  if (slicedSegments.length === 0 &&
-      containsEmptyPathRedirects(segmentGroup, slicedSegments, config)) {
-    const s = new UrlSegmentGroup(
-        segmentGroup.segments,
-        addEmptySegmentsToChildrenIfNeeded(
-            segmentGroup, slicedSegments, config, segmentGroup.children));
-    return {segmentGroup: mergeTrivialChildren(s), slicedSegments};
-  }
-
-  return {segmentGroup, slicedSegments};
-}
 
+/**
+ * When possible, merges the primary outlet child into the parent `UrlSegmentGroup`.
+ *
+ * When a segment group has only one child which is a primary outlet, merges that child into the
+ * parent. That is, the child segment group's segments are merged into the `s` and the child's
+ * children become the children of `s`. Think of this like a 'squash', merging the child segment
+ * group into the parent.
+ */
 function mergeTrivialChildren(s: UrlSegmentGroup): UrlSegmentGroup {
   if (s.numberOfChildren === 1 && s.children[PRIMARY_OUTLET]) {
     const c = s.children[PRIMARY_OUTLET];
@@ -534,46 +491,20 @@ function mergeTrivialChildren(s: UrlSegmentGroup): UrlSegmentGroup {
   return s;
 }
 
-function addEmptySegmentsToChildrenIfNeeded(
-    segmentGroup: UrlSegmentGroup, slicedSegments: UrlSegment[], routes: Route[],
-    children: {[name: string]: UrlSegmentGroup}): {[name: string]: UrlSegmentGroup} {
-  const res: {[name: string]: UrlSegmentGroup} = {};
-  for (const r of routes) {
-    if (isEmptyPathRedirect(segmentGroup, slicedSegments, r) && !children[getOutlet(r)]) {
-      res[getOutlet(r)] = new UrlSegmentGroup([], {});
-    }
-  }
-  return {...children, ...res};
-}
-
-function createChildrenForEmptySegments(
-    routes: Route[], primarySegmentGroup: UrlSegmentGroup): {[name: string]: UrlSegmentGroup} {
-  const res: {[name: string]: UrlSegmentGroup} = {};
-  res[PRIMARY_OUTLET] = primarySegmentGroup;
-  for (const r of routes) {
-    if (r.path === '' && getOutlet(r) !== PRIMARY_OUTLET) {
-      res[getOutlet(r)] = new UrlSegmentGroup([], {});
+/**
+ * Recursively merges primary segment children into their parents and also drops empty children
+ * (those which have no segments and no children themselves). The latter prevents serializing a
+ * group into something like `/a(aux:)`, where `aux` is an empty child segment.
+ */
+function squashSegmentGroup(segmentGroup: UrlSegmentGroup): UrlSegmentGroup {
+  const newChildren = {} as any;
+  for (const [childOutlet, child] of Object.entries(segmentGroup.children)) {
+    const childCandidate = squashSegmentGroup(child);
+    // don't add empty children
+    if (childCandidate.segments.length > 0 || childCandidate.hasChildren()) {
+      newChildren[childOutlet] = childCandidate;
     }
   }
-  return res;
-}
-
-function containsEmptyPathRedirectsWithNamedOutlets(
-    segmentGroup: UrlSegmentGroup, segments: UrlSegment[], routes: Route[]): boolean {
-  return routes.some(
-      r => isEmptyPathRedirect(segmentGroup, segments, r) && getOutlet(r) !== PRIMARY_OUTLET);
-}
-
-function containsEmptyPathRedirects(
-    segmentGroup: UrlSegmentGroup, segments: UrlSegment[], routes: Route[]): boolean {
-  return routes.some(r => isEmptyPathRedirect(segmentGroup, segments, r));
-}
-
-function isEmptyPathRedirect(
-    segmentGroup: UrlSegmentGroup, segments: UrlSegment[], r: Route): boolean {
-  if ((segmentGroup.hasChildren() || segments.length > 0) && r.pathMatch === 'full') {
-    return false;
-  }
-
-  return r.path === '' && r.redirectTo !== undefined;
+  const s = new UrlSegmentGroup(segmentGroup.segments, newChildren);
+  return mergeTrivialChildren(s);
 }