jsyntax 0.1.0

Structured Java source construction for Rust decompilers and code generators
Documentation
use super::declaration::BodyKind;
use super::{Printer, Result};
use crate::ast::*;
use crate::version::Feature;

impl Printer<'_> {
    pub(super) fn compilation_unit(&mut self, unit: &CompilationUnit) -> Result {
        self.comments(&unit.comments)?;
        if let Some(package) = &unit.package {
            self.annotations(&package.annotations, true)?;
            self.text("package ");
            self.qualified(&package.name, false)?;
            self.text(";");
            self.newline();
            self.newline();
        }
        self.imports(&unit.imports)?;
        for (index, declaration) in unit.types.iter().enumerate() {
            if declaration.meta.modifiers.iter().any(|m| {
                matches!(
                    m,
                    Modifier::Private | Modifier::Protected | Modifier::Static
                )
            }) {
                return Err(Self::invalid(
                    "top-level types cannot be private, protected or static",
                ));
            }
            if index != 0 {
                self.newline();
            }
            self.type_decl(declaration)?;
        }
        Ok(())
    }

    pub(super) fn compact_unit(&mut self, unit: &CompactUnit) -> Result {
        self.require(Feature::CompactUnits)?;
        self.comments(&unit.comments)?;
        self.imports(&unit.imports)?;
        self.members(&unit.members, BodyKind::Compact, None)
    }

    pub(super) fn imports(&mut self, imports: &[Import]) -> Result {
        for import in imports {
            self.text("import ");
            match import {
                Import::Type(name) => self.qualified(name, true)?,
                Import::OnDemand(name) => {
                    self.qualified(name, false)?;
                    self.text(".*");
                }
                Import::Static { owner, member } => {
                    self.require(Feature::StaticImports)?;
                    self.text("static ");
                    self.qualified(owner, true)?;
                    self.text(".");
                    if let Some(member) = member {
                        self.identifier(member)?;
                    } else {
                        self.text("*");
                    }
                }
                Import::Module(name) => {
                    self.require(Feature::ModuleImports)?;
                    self.text("module ");
                    self.qualified(name, false)?;
                }
            }
            self.text(";");
            self.newline();
        }
        if !imports.is_empty() {
            self.newline();
        }
        Ok(())
    }

    pub(super) fn module_unit(&mut self, unit: &ModuleUnit) -> Result {
        self.require(Feature::Modules)?;
        self.imports(&unit.imports)?;
        self.module(&unit.declaration)
    }

    pub(super) fn module(&mut self, module: &ModuleDecl) -> Result {
        self.require(Feature::Modules)?;
        self.comments(&module.comments)?;
        self.annotations(&module.annotations, true)?;
        if module.open {
            self.text("open ");
        }
        self.text("module ");
        self.qualified(&module.name, false)?;
        self.text(" ");
        self.open_block();
        for directive in &module.directives {
            match directive {
                ModuleDirective::Requires {
                    name,
                    static_,
                    transitive,
                } => {
                    self.text("requires ");
                    if *static_ {
                        self.text("static ");
                    }
                    if *transitive {
                        self.text("transitive ");
                    }
                    self.qualified(name, false)?;
                }
                ModuleDirective::Exports { package, to }
                | ModuleDirective::Opens { package, to } => {
                    let opens = matches!(directive, ModuleDirective::Opens { .. });
                    if module.open && opens {
                        return Err(Self::invalid(
                            "an open module cannot contain opens directives",
                        ));
                    }
                    self.text(if opens { "opens " } else { "exports " });
                    self.qualified(package, false)?;
                    if !to.is_empty() {
                        self.text(" to ");
                        self.separated(to, ", ", |p, name| p.qualified(name, false))?;
                    }
                }
                ModuleDirective::Uses(service) => {
                    self.text("uses ");
                    self.qualified(service, true)?;
                }
                ModuleDirective::Provides {
                    service,
                    implementations,
                } => {
                    if implementations.is_empty() {
                        return Err(Self::invalid(
                            "provides requires at least one implementation",
                        ));
                    }
                    self.text("provides ");
                    self.qualified(service, true)?;
                    self.text(" with ");
                    self.separated(implementations, ", ", |p, name| p.qualified(name, true))?;
                }
            }
            self.text(";");
            self.newline();
        }
        self.close_block();
        self.newline();
        Ok(())
    }
}