Quelle  import.rs

use crate::core::*;
use crate::kw;
use crate::parser::{Cursor, Parse, Parser, Peek, Result};
use crate::token::{Id, LParen, NameAnnotation, Span};

/// An `import` statement and entry in a WebAssembly module.
#[derive(Debug, Clone)]
pub struct Imports<'a> {
    /// Where this `import` statement was defined.
    pub span: Span,
    /// All items inside the `import` statement.
    pub items: ImportItems<'a>,
}

/// The individual items inside an `import` statement, possibly in one of the
/// "compact" forms.
#[derive(Debug, Clone)]
pub enum ImportItems<'a> {
    /// A single import item:
    ///
    /// ```text
    /// (import "mod" "name" <type>)
    /// ```
    Single {
        /// The name of the module being importing from.
        module: &'a str,
        /// The name of the field in the module being imported from.
        name: &'a str,
        /// The type of the item being imported.
        sig: ItemSig<'a>,
    },

    /// A group of import items with a common module name:
    ///
    /// ```text
    /// (import "mod" (item "foo" <type>) (item "bar" <type>))
    /// ```
    Group1 {
        /// The name of the module being imported from.
        module: &'a str,
        /// The individual items being imported (name/type).
        items: Vec<ImportGroup1Item<'a>>,
    },

    /// A group of import items with a common module name and type:
    ///
    /// ```text
    /// (import "mod" (item "foo") (item "bar") <type>)
    /// ```
    Group2 {
        /// The name of the module being imported from.
        module: &'a str,
        /// The type of all the items being imported.
        sig: ItemSig<'a>,
        /// The individual items being imported (names only).
        items: Vec<ImportGroup2Item<'a>>,
    },
}

/// An item in a group of compact imports sharing a module name. Used with [`ImportItems::Group1`].
///
/// ```text
/// (item "foo" <type>)
/// ```
#[derive(Debug, Clone)]
pub struct ImportGroup1Item<'a> {
    /// Where this `item` was defined.
    pub span: Span,
    /// The name of the item being imported.
    pub name: &'a str,
    /// The type of the item being imported.
    pub sig: ItemSig<'a>,
}

/// An item in a group of compact imports sharing a module name and type. Used with [`ImportItems::Group2`].
#[derive(Debug, Clone)]
pub struct ImportGroup2Item<'a> {
    /// Where this `item` was defined.
    pub span: Span,
    /// The name of the item being imported.
    pub name: &'a str,
}

enum CompactImportEncoding {
    Unknown,
    Encoding1,
    Encoding2,
}

impl<'a> Imports<'a> {
    /// Constructs an Imports object for a single import item.
    pub fn single(span: Span, module: &'a str, name: &'a str, sig: ItemSig<'a>) -> Self {
        Self {
            span,
            items: ImportItems::Single { module, name, sig },
        }
    }

    /// Returns the number of import items defined in the group.
    pub fn num_items(&self) -> usize {
        match &self.items {
            ImportItems::Single {
                module: _,
                name: _,
                sig: _,
            } => 1,
            ImportItems::Group1 { module: _, items } => items.len(),
            ImportItems::Group2 {
                module: _,
                sig: _,
                items,
            } => items.len(),
        }
    }

    /// Returns the ItemSig for each defined import in the group. Items using
    /// compact encoding 2 will share an ItemSig.
    pub fn item_sigs(&self) -> Vec<&ItemSig<'a>> {
        let res = match &self.items {
            ImportItems::Single {
                module: _,
                name: _,
                sig,
            } => vec![sig],
            ImportItems::Group1 { module: _, items } => {
                items.iter().map(|item| &item.sig).collect()
            }
            ImportItems::Group2 {
                module: _,
                sig,
                items,
            } => vec![sig; items.len()],
        };
        debug_assert!(res.len() == self.num_items());
        res
    }

    /// Returns mutable references to each ItemSig defined in the group. This
    /// may be less than the number of imports defined in the group, if items
    /// share a sig.
    pub fn unique_sigs_mut(&mut self) -> Vec<&mut ItemSig<'a>> {
        match &mut self.items {
            ImportItems::Single {
                module: _,
                name: _,
                sig: item,
            } => vec![item],
            ImportItems::Group1 { module: _, items } => {
                items.iter_mut().map(|item| &mut item.sig).collect()
            }
            ImportItems::Group2 {
                module: _,
                sig,
                items: _,
            } => vec![sig],
        }
    }
}

struct ImportGroupItemCommon<'a> {
    span: Span,
    name: &'a str,
    sig: Option<ItemSig<'a>>,
}

impl<'a> Parse<'a> for Imports<'a> {
    fn parse(parser: Parser<'a>) -> Result<Self> {
        let span = parser.parse::<kw::import>()?.0;
        let module = parser.parse()?;
        if parser.peek::<LParen>()? {
            let mut encoding = CompactImportEncoding::Unknown;
            let mut items = Vec::new();
            while parser.peek2::<kw::item>()? {
                let item: ImportGroupItemCommon = parser.parens(|p| p.parse())?;
                match item.sig {
                    Some(_) => {
                        // Compact encoding 1 (name / type pairs)
                        match encoding {
                            CompactImportEncoding::Unknown => {
                                encoding = CompactImportEncoding::Encoding1
                            }
                            CompactImportEncoding::Encoding1 => {}
                            CompactImportEncoding::Encoding2 => {
                                return Err(parser.error("unexpected import type"));
                            }
                        }
                    }
                    None => {
                        // Compact encoding 2 (names only)
                        match encoding {
                            CompactImportEncoding::Unknown => {
                                encoding = CompactImportEncoding::Encoding2
                            }
                            CompactImportEncoding::Encoding1 => {
                                return Err(parser.error("unexpected `)`"));
                            }
                            CompactImportEncoding::Encoding2 => {}
                        }
                    }
                }
                items.push(item);
            }

            match encoding {
                CompactImportEncoding::Unknown => Err(parser.error("expected import items")),
                CompactImportEncoding::Encoding1 => Ok(Imports {
                    span,
                    items: ImportItems::Group1 {
                        module,
                        items: items
                            .into_iter()
                            .map(|item| ImportGroup1Item {
                                span: item.span,
                                name: item.name,
                                sig: item.sig.unwrap(),
                            })
                            .collect(),
                    },
                }),
                CompactImportEncoding::Encoding2 => {
                    let sig: ItemSig = parser.parens(|p| p.parse())?;
                    if let Some(id) = sig.id {
                        return Err(parser.error_at(id.span(), "identifier not allowed"));
                    }
                    Ok(Imports {
                        span,
                        items: ImportItems::Group2 {
                            module,
                            sig,
                            items: items
                                .into_iter()
                                .map(|item| ImportGroup2Item {
                                    span: item.span,
                                    name: item.name,
                                })
                                .collect(),
                        },
                    })
                }
            }
        } else {
            // Single item
            let field = parser.parse()?;
            let sig = parser.parens(|p| p.parse())?;
            Ok(Imports::single(span, module, field, sig))
        }
    }
}

impl<'a> Parse<'a> for ImportGroupItemCommon<'a> {
    fn parse(parser: Parser<'a>) -> Result<Self> {
        let span = parser.parse::<kw::item>()?.0;
        Ok(ImportGroupItemCommon {
            span,
            name: parser.parse()?,
            sig: if parser.is_empty() {
                None
            } else {
                Some(parser.parens(|p| p.parse())?)
            },
        })
    }
}

#[derive(Debug, Clone)]
#[allow(missing_docs)]
pub struct ItemSig<'a> {
    /// Where this item is defined in the source.
    pub span: Span,
    /// An optional identifier used during name resolution to refer to this item
    /// from the rest of the module.
    pub id: Option<Id<'a>>,
    /// An optional name which, for functions, will be stored in the
    /// custom `name` section.
    pub name: Option<NameAnnotation<'a>>,
    /// What kind of item this is.
    pub kind: ItemKind<'a>,
}

#[derive(Debug, Clone)]
#[allow(missing_docs)]
pub enum ItemKind<'a> {
    Func(TypeUse<'a, FunctionType<'a>>),
    Table(TableType<'a>),
    Memory(MemoryType),
    Global(GlobalType<'a>),
    Tag(TagType<'a>),
    FuncExact(TypeUse<'a, FunctionType<'a>>),
}

impl<'a> Parse<'a> for ItemSig<'a> {
    fn parse(parser: Parser<'a>) -> Result<Self> {
        let mut l = parser.lookahead1();
        if l.peek::<kw::func>()? {
            let span = parser.parse::<kw::func>()?.0;
            let id = parser.parse()?;
            let name = parser.parse()?;
            let kind = if parser.peek2::<kw::exact>()? {
                ItemKind::FuncExact(parser.parens(|p| {
                    p.parse::<kw::exact>()?;
                    p.parse()
                })?)
            } else {
                ItemKind::Func(parser.parse()?)
            };
            Ok(ItemSig {
                span,
                id,
                name,
                kind,
            })
        } else if l.peek::<kw::table>()? {
            let span = parser.parse::<kw::table>()?.0;
            Ok(ItemSig {
                span,
                id: parser.parse()?,
                name: None,
                kind: ItemKind::Table(parser.parse()?),
            })
        } else if l.peek::<kw::memory>()? {
            let span = parser.parse::<kw::memory>()?.0;
            Ok(ItemSig {
                span,
                id: parser.parse()?,
                name: None,
                kind: ItemKind::Memory(parser.parse()?),
            })
        } else if l.peek::<kw::global>()? {
            let span = parser.parse::<kw::global>()?.0;
            Ok(ItemSig {
                span,
                id: parser.parse()?,
                name: None,
                kind: ItemKind::Global(parser.parse()?),
            })
        } else if l.peek::<kw::tag>()? {
            let span = parser.parse::<kw::tag>()?.0;
            Ok(ItemSig {
                span,
                id: parser.parse()?,
                name: None,
                kind: ItemKind::Tag(parser.parse()?),
            })
        } else {
            Err(l.error())
        }
    }
}

/// A listing of a inline `(import "foo")` statement.
///
/// Note that when parsing this type it is somewhat unconventional that it
/// parses its own surrounding parentheses. This is typically an optional type,
/// so it's so far been a bit nicer to have the optionality handled through
/// `Peek` rather than `Option<T>`.
#[derive(Debug, Copy, Clone)]
#[allow(missing_docs)]
pub struct InlineImport<'a> {
    pub module: &'a str,
    pub field: &'a str,
}

impl<'a> Parse<'a> for InlineImport<'a> {
    fn parse(parser: Parser<'a>) -> Result<Self> {
        parser.parens(|p| {
            p.parse::<kw::import>()?;
            Ok(InlineImport {
                module: p.parse()?,
                field: p.parse()?,
            })
        })
    }
}

impl Peek for InlineImport<'_> {
    fn peek(cursor: Cursor<'_>) -> Result<bool> {
        let cursor = match cursor.lparen()? {
            Some(cursor) => cursor,
            None => return Ok(false),
        };
        let cursor = match cursor.keyword()? {
            Some(("import", cursor)) => cursor,
            _ => return Ok(false),
        };
        let cursor = match cursor.string()? {
            Some((_, cursor)) => cursor,
            None => return Ok(false),
        };
        let cursor = match cursor.string()? {
            Some((_, cursor)) => cursor,
            None => return Ok(false),
        };

        Ok(cursor.rparen()?.is_some())
    }

    fn display() -> &'static str {
        "inline import"
    }
}