#![allow(unused_imports)]
#![allow(unused_variables)]
use crate::common::errors::DiagBuilder2;
use crate::common::errors::*;
use crate::common::name::{get_name_table, Name};
use crate::common::source::Spanned;
use crate::common::{Session, SessionContext, Verbosity};
use crate::arenas::{Alloc, AllocOwned};
use crate::hir::visit::Visitor;
use crate::hir::{self, Decl2, FromAst, LatentNode, Library, Node};
use crate::konst2::{self, Const2, OwnedConst};
use crate::scope2::ScopeData;
use crate::syntax::ast;
use crate::ty2;
pub fn emit_pkgs(sess: &Session, nodes: Vec<&ast::DesignUnit>) {
let (arenas, type_arena, const_arena) = (
hir::Arenas2::new(),
ty2::TypeArena::new(),
konst2::ConstArena::new(),
);
let scope = arenas.alloc(ScopeData::root());
let ctx = hir::AllocContext {
sess: sess,
arenas: &arenas,
scope: scope,
};
let name = get_name_table().intern("magic", true);
let lib = Library::new(name, &nodes, ctx).unwrap();
if sess.failed() {
return;
}
debugln!("forcing HIR creation");
lib.accept(&mut IdentityVisitor);
debugln!("listing type declarations");
let mut v = TypeVisitor {
sess: sess,
type_arena: &type_arena,
const_arena: &const_arena,
};
lib.accept(&mut v);
}
struct IdentityVisitor;
impl<'t> Visitor<'t> for IdentityVisitor {
fn as_visitor(&mut self) -> &mut Visitor<'t> {
self
}
}
#[derive(Copy, Clone)]
struct TypeVisitor<'t> {
sess: &'t Session,
type_arena: &'t ty2::TypeArena<'t>,
const_arena: &'t konst2::ConstArena<'t>,
}
impl<'a, 't: 'a> SessionContext for &'a TypeVisitor<'t> {
fn has_verbosity(&self, verb: Verbosity) -> bool {
self.sess.has_verbosity(verb)
}
}
impl<'a, 't: 'a> DiagEmitter for &'a TypeVisitor<'t> {
fn emit(&self, diag: DiagBuilder2) {
self.sess.emit(diag);
}
}
impl<'b, 'a, 't: 'a, T: 't> Alloc<'b, 't, T> for &'a TypeVisitor<'t>
where
ty2::TypeArena<'t>: Alloc<'t, 't, T>,
{
fn alloc(&'b self, value: T) -> &'t mut T {
self.type_arena.alloc(value)
}
}
impl<'b, 'a, 't: 'a> Alloc<'b, 't, konst2::IntegerConst<'t>> for &'a TypeVisitor<'t> {
fn alloc(&'b self, value: konst2::IntegerConst<'t>) -> &'t mut konst2::IntegerConst<'t> {
self.const_arena.alloc(value)
}
}
impl<'a, 'b, 't: 'a> AllocOwned<'b, 't, konst2::Const2<'t>> for &'a TypeVisitor<'t> {
fn alloc_owned(&'b self, value: OwnedConst<'t>) -> &'t Const2<'t> {
self.const_arena.alloc_owned(value)
}
}
impl<'a, 'b, 't: 'a> AllocOwned<'b, 't, ty2::Type> for &'a TypeVisitor<'t> {
fn alloc_owned(&'b self, value: ty2::OwnedType<'t>) -> &'t ty2::Type {
self.type_arena.alloc_owned(value)
}
}
impl<'t> Visitor<'t> for TypeVisitor<'t> {
fn as_visitor(&mut self) -> &mut Visitor<'t> {
self
}
fn visit_type_decl(&mut self, decl: &'t hir::TypeDecl2<'t>) {
if let Ok(t) = decl.declared_type(self as &_) {
debugln!("type {} = {}", decl.name(), t);
}
decl.walk(self);
}
}