Method resolve_impl

libs/@local/hashql/core/src/module/resolver.rs:190–255

(
        &self,
        query: impl IntoIterator<Item = Symbol<'heap>>,
        mut module: Module<'heap>,
    )

    #[define_opaque(ModuleItemIterator)]
    fn resolve_impl(
        &self,
        query: impl IntoIterator<Item = Symbol<'heap>>,
        mut module: Module<'heap>,
    ) -> Result<ResolveIter<'heap>, ResolutionError<'heap>> {
        let mut query = query.into_iter().enumerate().peekable();

        // In case that we're in glob mode and the query is empty (which is only valid in glob
        // mode), return all items
        if query.peek().is_none() && self.options.mode == ResolverMode::Glob {
            if module.items.is_empty() {
                return Err(ResolutionError::ModuleEmpty { depth: 0 });
            }

            return Ok(ResolveIter::Glob(
                module.items.into_iter().copied().map(Reference::Item),
            ));
        }

        // Traverse the entry until we're at the last item
        let (depth, name) = loop {
            let Some((mut depth, name)) = query.next() else {
                return Err(ResolutionError::InvalidQueryLength { expected: 2 });
            };

            // We start at 1, because the entry (the one we're starting at) is selected by the user
            depth += 1;

            if query.peek().is_none() {
                // The last item is the entry we're trying to resolve to
                break (depth, name);
            }

            let Some(&item) = module.items.iter().find(|item| item.name == name) else {
                return Err(ResolutionError::ModuleNotFound {
                    depth,
                    name,
                    suggestions: self.suggest(|| {
                        module.suggestions(|item| matches!(item.kind, ItemKind::Module(_)))
                    }),
                });
            };

            // Because we're not at the last item, the item needs to be a module
            let ItemKind::Module(next) = item.kind else {
                return Err(ResolutionError::ModuleRequired {
                    depth,
                    found: item.kind.universe(),
                });
            };

            module = self.registry.modules.index(next);
        };

        match self.options.mode {
            ResolverMode::Single(universe) => self
                .resolve_single(module, universe, name, depth)
                .map(ResolveIter::Single),