document.querySelector('[data-channel]')!.dataset.channel
// string | undefined                   ^ forgive this, demo only

const selectors = {
  'TSNonNullExpression > TSNonNullExpression'(node: TSESTree. TSNonNullExpression) {
    // guaranteed by the selector, but currently impossible to represent in types
    const parent = node.parent as TSESTree.TSNonNullExpression;
  },
  'VariableDeclarator[init]'(node: TSESTree.VariableDeclarator) {
    // selector guarantees non-null, but is hard to nicely represent in types
    const init = node.init!;
  },
  // the only way to properly type this at declaration time
  'VariableDeclarator[init]'(node: TSESTree.VariableDeclarator & {
    init: NonNullable<TSESTree.VariableDeclarator['init']>;
  }) {
    const init = node.init; // correctly non-nullish
  },
  // or solve it with runtime checks
  'VariableDeclarator[init]'(node: TSESTree.VariableDeclarator) {
    /* istanbul ignore if */ if (node.init == null) {
      return;
    }
    const init = node.init;
  },
  'VariableDeclarator[init]'(node: TSESTree.VariableDeclarator) {
    const init = nullthrows(node.init, 'found no init on VariableDeclarator');
  },
}

function nullthrows<T>(thing: T, msg: string): NonNullable<T> {
  if (thing == null) { throw new Error(msg) }
  return thing;
}

return {
  'TSAsExpression, TSTypeAssertion'(node) {
    const baseType = getTypeAtLocation(node.expression);
    if (!isUnionType(baseType) || !containsNullishTypes(baseType)) {
      // non-nullish and non-union types cannot be non-null asserted on
      return;
    }
    const assertedType = getTypeAtLocation(node.expression);
    if (containsNullishTypes(baseType)) {
      // asserting from string | null | undefined to string | null is fine
      return;
    }
    
    for (const base of baseType.filter(nullishTypes)) {
      if (!assertedType.contains(base)) {
        return; // asserted type is not an exact NonNullable conversion
      }
    }
    
    context.report('use a ! instead');
  },
}