Remove collect-identifiers example
This commit is contained in:
parent
3b0190b389
commit
fa51f14db5
@ -1,525 +0,0 @@
|
|||||||
//! Collects identifiers into a list
|
|
||||||
|
|
||||||
use cl_lexer::Lexer;
|
|
||||||
use cl_parser::Parser;
|
|
||||||
use cl_repl::repline::Repline;
|
|
||||||
use cl_structures::span::Loc;
|
|
||||||
use std::{
|
|
||||||
collections::HashMap,
|
|
||||||
error::Error,
|
|
||||||
fmt::Display,
|
|
||||||
ops::{Deref, DerefMut},
|
|
||||||
};
|
|
||||||
|
|
||||||
fn main() -> Result<(), Box<dyn Error>> {
|
|
||||||
let mut rl = Repline::new("\x1b[33m", "cl>", "? >");
|
|
||||||
while let Ok(line) = rl.read() {
|
|
||||||
let mut parser = Parser::new(Lexer::new(&line));
|
|
||||||
let code = match parser.stmt() {
|
|
||||||
Ok(code) => {
|
|
||||||
rl.accept();
|
|
||||||
code
|
|
||||||
}
|
|
||||||
Err(_) => {
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
};
|
|
||||||
let c = Collector::from(&code);
|
|
||||||
print!("\x1b[G\x1b[J{c}");
|
|
||||||
}
|
|
||||||
Ok(())
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Ties the [Collector] location stack to the program stack
|
|
||||||
pub struct CollectorLoc<'loc, 'code> {
|
|
||||||
inner: &'loc mut Collector<'code>,
|
|
||||||
}
|
|
||||||
impl<'l, 'c> CollectorLoc<'l, 'c> {
|
|
||||||
pub fn new(c: &'l mut Collector<'c>, loc: Loc) -> Self {
|
|
||||||
c.location.push(loc);
|
|
||||||
Self { inner: c }
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<'l, 'c> Deref for CollectorLoc<'l, 'c> {
|
|
||||||
type Target = Collector<'c>;
|
|
||||||
fn deref(&self) -> &Self::Target {
|
|
||||||
self.inner
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<'l, 'c> DerefMut for CollectorLoc<'l, 'c> {
|
|
||||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
|
||||||
self.inner
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<'l, 'c> Drop for CollectorLoc<'l, 'c> {
|
|
||||||
fn drop(&mut self) {
|
|
||||||
let Self { inner: c } = self;
|
|
||||||
c.location.pop();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[derive(Clone, Debug, Default)]
|
|
||||||
pub struct Collector<'code> {
|
|
||||||
location: Vec<Loc>,
|
|
||||||
defs: HashMap<&'code str, Vec<Loc>>,
|
|
||||||
refs: HashMap<&'code str, Vec<Loc>>,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<'c> Collector<'c> {
|
|
||||||
pub fn new() -> Self {
|
|
||||||
Self::default()
|
|
||||||
}
|
|
||||||
pub fn location<'loc>(&'loc mut self, loc: Loc) -> CollectorLoc<'loc, 'c> {
|
|
||||||
CollectorLoc::new(self, loc)
|
|
||||||
}
|
|
||||||
pub fn collect(&mut self, collectible: &'c impl Collectible<'c>) -> &mut Self {
|
|
||||||
collectible.collect(self);
|
|
||||||
self
|
|
||||||
}
|
|
||||||
pub fn define(&mut self, name: &'c str) -> &mut Self {
|
|
||||||
// println!("Inserted definition of {name}");
|
|
||||||
let loc = self.location.last().copied().unwrap_or(Loc(0, 0));
|
|
||||||
self.defs
|
|
||||||
.entry(name)
|
|
||||||
.and_modify(|c| c.push(loc))
|
|
||||||
.or_insert_with(|| vec![loc]);
|
|
||||||
self
|
|
||||||
}
|
|
||||||
pub fn reference(&mut self, name: &'c str) -> &mut Self {
|
|
||||||
// println!("Inserted usage of {name}");
|
|
||||||
let loc = self.location.last().copied().unwrap_or(Loc(0, 0));
|
|
||||||
self.refs
|
|
||||||
.entry(name)
|
|
||||||
.and_modify(|c| c.push(loc))
|
|
||||||
.or_insert_with(|| vec![loc]);
|
|
||||||
self
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<'c> Display for Collector<'c> {
|
|
||||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
||||||
let Self { location: _, defs, refs } = self;
|
|
||||||
writeln!(f, "Definitions:")?;
|
|
||||||
for (name, locs) in defs {
|
|
||||||
for loc in locs {
|
|
||||||
writeln!(f, "{loc} {name}")?;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
writeln!(f, "Usages:")?;
|
|
||||||
for (name, locs) in refs {
|
|
||||||
for loc in locs {
|
|
||||||
writeln!(f, "{loc} {name}")?;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
Ok(())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<'c, C: Collectible<'c>> From<&'c C> for Collector<'c> {
|
|
||||||
fn from(value: &'c C) -> Self {
|
|
||||||
let mut c = Self::new();
|
|
||||||
c.collect(value);
|
|
||||||
c
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
use collectible::Collectible;
|
|
||||||
pub mod collectible {
|
|
||||||
|
|
||||||
use super::Collector;
|
|
||||||
use cl_ast::*;
|
|
||||||
pub trait Collectible<'code> {
|
|
||||||
fn collect(&'code self, c: &mut Collector<'code>);
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<'c> Collectible<'c> for File {
|
|
||||||
fn collect(&'c self, c: &mut Collector<'c>) {
|
|
||||||
let File { items } = self;
|
|
||||||
for item in items {
|
|
||||||
item.collect(c)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<'c> Collectible<'c> for Item {
|
|
||||||
fn collect(&'c self, c: &mut Collector<'c>) {
|
|
||||||
let Self { extents, attrs: _, vis: _, kind } = self;
|
|
||||||
kind.collect(&mut c.location(extents.head));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<'c> Collectible<'c> for ItemKind {
|
|
||||||
fn collect(&'c self, c: &mut Collector<'c>) {
|
|
||||||
match self {
|
|
||||||
ItemKind::Alias(f) => f.collect(c),
|
|
||||||
ItemKind::Const(f) => f.collect(c),
|
|
||||||
ItemKind::Static(f) => f.collect(c),
|
|
||||||
ItemKind::Module(f) => f.collect(c),
|
|
||||||
ItemKind::Function(f) => f.collect(c),
|
|
||||||
ItemKind::Struct(f) => f.collect(c),
|
|
||||||
ItemKind::Enum(f) => f.collect(c),
|
|
||||||
ItemKind::Impl(f) => f.collect(c),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<'c> Collectible<'c> for Alias {
|
|
||||||
fn collect(&'c self, c: &mut Collector<'c>) {
|
|
||||||
let Self { to, from } = self;
|
|
||||||
c.collect(to).collect(from);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<'c> Collectible<'c> for Const {
|
|
||||||
fn collect(&'c self, c: &mut Collector<'c>) {
|
|
||||||
let Self { name: Identifier(name), ty, init } = self;
|
|
||||||
c.define(name).collect(init).collect(ty);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<'c> Collectible<'c> for Static {
|
|
||||||
fn collect(&'c self, c: &mut Collector<'c>) {
|
|
||||||
let Self { mutable: _, name: Identifier(name), ty, init } = self;
|
|
||||||
c.define(name).collect(init).collect(ty);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<'c> Collectible<'c> for Module {
|
|
||||||
fn collect(&'c self, c: &mut Collector<'c>) {
|
|
||||||
let Self { name: Identifier(name), kind } = self;
|
|
||||||
c.define(name).collect(kind);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<'c> Collectible<'c> for ModuleKind {
|
|
||||||
fn collect(&'c self, c: &mut Collector<'c>) {
|
|
||||||
match self {
|
|
||||||
ModuleKind::Inline(f) => f.collect(c),
|
|
||||||
ModuleKind::Outline => {}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<'c> Collectible<'c> for Function {
|
|
||||||
fn collect(&'c self, c: &mut Collector<'c>) {
|
|
||||||
let Self { name: Identifier(name), args, body, rety } = self;
|
|
||||||
c.define(name).collect(args).collect(body).collect(rety);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<'c> Collectible<'c> for Struct {
|
|
||||||
fn collect(&'c self, c: &mut Collector<'c>) {
|
|
||||||
let Self { name: Identifier(name), kind } = self;
|
|
||||||
c.define(name).collect(kind);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<'c> Collectible<'c> for StructKind {
|
|
||||||
fn collect(&'c self, c: &mut Collector<'c>) {
|
|
||||||
match self {
|
|
||||||
StructKind::Empty => {}
|
|
||||||
StructKind::Tuple(k) => k.collect(c),
|
|
||||||
StructKind::Struct(k) => k.collect(c),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<'c> Collectible<'c> for StructMember {
|
|
||||||
fn collect(&'c self, c: &mut Collector<'c>) {
|
|
||||||
let Self { vis: _, name: Identifier(name), ty } = self;
|
|
||||||
c.define(name).collect(ty);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<'c> Collectible<'c> for Enum {
|
|
||||||
fn collect(&'c self, c: &mut Collector<'c>) {
|
|
||||||
let Self { name: Identifier(name), kind } = self;
|
|
||||||
c.define(name).collect(kind);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<'c> Collectible<'c> for EnumKind {
|
|
||||||
fn collect(&'c self, c: &mut Collector<'c>) {
|
|
||||||
match self {
|
|
||||||
EnumKind::NoVariants => {}
|
|
||||||
EnumKind::Variants(v) => v.collect(c),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<'c> Collectible<'c> for Variant {
|
|
||||||
fn collect(&'c self, c: &mut Collector<'c>) {
|
|
||||||
let Self { name: Identifier(name), kind } = self;
|
|
||||||
c.define(name).collect(kind);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<'c> Collectible<'c> for VariantKind {
|
|
||||||
fn collect(&'c self, c: &mut Collector<'c>) {
|
|
||||||
match self {
|
|
||||||
VariantKind::Plain => {}
|
|
||||||
VariantKind::CLike(_) => {}
|
|
||||||
VariantKind::Tuple(v) => v.collect(c),
|
|
||||||
VariantKind::Struct(v) => v.collect(c),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<'c> Collectible<'c> for Impl {
|
|
||||||
fn collect(&'c self, c: &mut Collector<'c>) {
|
|
||||||
let Self { target, body } = self;
|
|
||||||
c.collect(target).collect(body);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<'c> Collectible<'c> for Block {
|
|
||||||
fn collect(&'c self, c: &mut Collector<'c>) {
|
|
||||||
let Self { stmts } = self;
|
|
||||||
for stmt in stmts {
|
|
||||||
stmt.collect(c);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<'c> Collectible<'c> for Stmt {
|
|
||||||
fn collect(&'c self, c: &mut Collector<'c>) {
|
|
||||||
let Self { extents, kind, semi: _ } = self;
|
|
||||||
c.location(extents.head).collect(kind);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<'c> Collectible<'c> for StmtKind {
|
|
||||||
fn collect(&'c self, c: &mut Collector<'c>) {
|
|
||||||
match self {
|
|
||||||
StmtKind::Empty => {}
|
|
||||||
StmtKind::Local(s) => s.collect(c),
|
|
||||||
StmtKind::Item(s) => s.collect(c),
|
|
||||||
StmtKind::Expr(s) => s.collect(c),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<'c> Collectible<'c> for Let {
|
|
||||||
fn collect(&'c self, c: &mut Collector<'c>) {
|
|
||||||
let Self { mutable: _, name: Identifier(name), ty, init } = self;
|
|
||||||
c.collect(init).collect(ty).define(name);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<'c> Collectible<'c> for Expr {
|
|
||||||
fn collect(&'c self, c: &mut Collector<'c>) {
|
|
||||||
let Self { extents, kind } = self;
|
|
||||||
c.location(extents.head).collect(kind);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<'c> Collectible<'c> for ExprKind {
|
|
||||||
fn collect(&'c self, c: &mut Collector<'c>) {
|
|
||||||
match self {
|
|
||||||
ExprKind::Assign(k) => k.collect(c),
|
|
||||||
ExprKind::Binary(k) => k.collect(c),
|
|
||||||
ExprKind::Unary(k) => k.collect(c),
|
|
||||||
ExprKind::Member(k) => k.collect(c),
|
|
||||||
ExprKind::Call(k) => k.collect(c),
|
|
||||||
ExprKind::Index(k) => k.collect(c),
|
|
||||||
ExprKind::Path(k) => k.collect(c),
|
|
||||||
ExprKind::Literal(k) => k.collect(c),
|
|
||||||
ExprKind::Array(k) => k.collect(c),
|
|
||||||
ExprKind::ArrayRep(k) => k.collect(c),
|
|
||||||
ExprKind::AddrOf(k) => k.collect(c),
|
|
||||||
ExprKind::Block(k) => k.collect(c),
|
|
||||||
ExprKind::Empty => {}
|
|
||||||
ExprKind::Group(k) => k.collect(c),
|
|
||||||
ExprKind::Tuple(k) => k.collect(c),
|
|
||||||
ExprKind::While(k) => k.collect(c),
|
|
||||||
ExprKind::If(k) => k.collect(c),
|
|
||||||
ExprKind::For(k) => k.collect(c),
|
|
||||||
ExprKind::Break(k) => k.collect(c),
|
|
||||||
ExprKind::Return(k) => k.collect(c),
|
|
||||||
ExprKind::Continue(k) => k.collect(c),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<'c> Collectible<'c> for Assign {
|
|
||||||
fn collect(&'c self, c: &mut Collector<'c>) {
|
|
||||||
let Self { head, op: _, tail } = self;
|
|
||||||
c.collect(head).collect(tail);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<'c> Collectible<'c> for Binary {
|
|
||||||
fn collect(&'c self, c: &mut Collector<'c>) {
|
|
||||||
let Self { head, tail } = self;
|
|
||||||
c.collect(head);
|
|
||||||
for (_, tail) in tail {
|
|
||||||
c.collect(tail);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<'c> Collectible<'c> for Unary {
|
|
||||||
fn collect(&'c self, c: &mut Collector<'c>) {
|
|
||||||
let Self { ops: _, tail } = self;
|
|
||||||
c.collect(tail);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<'c> Collectible<'c> for Member {
|
|
||||||
fn collect(&'c self, c: &mut Collector<'c>) {
|
|
||||||
let Self { head, tail } = self;
|
|
||||||
c.collect(head).collect(tail);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<'c> Collectible<'c> for Call {
|
|
||||||
fn collect(&'c self, c: &mut Collector<'c>) {
|
|
||||||
let Self { callee, args } = self;
|
|
||||||
c.collect(callee).collect(args);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<'c> Collectible<'c> for Tuple {
|
|
||||||
fn collect(&'c self, c: &mut Collector<'c>) {
|
|
||||||
let Self { exprs } = self;
|
|
||||||
c.collect(exprs);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<'c> Collectible<'c> for Index {
|
|
||||||
fn collect(&'c self, c: &mut Collector<'c>) {
|
|
||||||
let Self { head, indices } = self;
|
|
||||||
c.collect(head).collect(indices);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<'c> Collectible<'c> for Indices {
|
|
||||||
fn collect(&'c self, c: &mut Collector<'c>) {
|
|
||||||
let Self { exprs } = self;
|
|
||||||
c.collect(exprs);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<'c> Collectible<'c> for Array {
|
|
||||||
fn collect(&'c self, c: &mut Collector<'c>) {
|
|
||||||
let Self { values } = self;
|
|
||||||
c.collect(values);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<'c> Collectible<'c> for ArrayRep {
|
|
||||||
fn collect(&'c self, c: &mut Collector<'c>) {
|
|
||||||
let Self { value, repeat } = self;
|
|
||||||
c.collect(value).collect(repeat);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<'c> Collectible<'c> for AddrOf {
|
|
||||||
fn collect(&'c self, c: &mut Collector<'c>) {
|
|
||||||
let Self { count: _, mutable: _, expr } = self;
|
|
||||||
c.collect(expr);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<'c> Collectible<'c> for Group {
|
|
||||||
fn collect(&'c self, c: &mut Collector<'c>) {
|
|
||||||
let Self { expr } = self;
|
|
||||||
c.collect(expr);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<'c> Collectible<'c> for While {
|
|
||||||
fn collect(&'c self, c: &mut Collector<'c>) {
|
|
||||||
let Self { cond, pass, fail } = self;
|
|
||||||
c.collect(cond).collect(pass).collect(fail);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<'c> Collectible<'c> for Else {
|
|
||||||
fn collect(&'c self, c: &mut Collector<'c>) {
|
|
||||||
let Self { body } = self;
|
|
||||||
c.collect(body);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<'c> Collectible<'c> for If {
|
|
||||||
fn collect(&'c self, c: &mut Collector<'c>) {
|
|
||||||
let Self { cond, pass, fail } = self;
|
|
||||||
c.collect(cond).collect(pass).collect(fail);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<'c> Collectible<'c> for For {
|
|
||||||
fn collect(&'c self, c: &mut Collector<'c>) {
|
|
||||||
let Self { bind: Identifier(name), cond, pass, fail } = self;
|
|
||||||
c.collect(cond).define(name).collect(pass).collect(fail);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<'c> Collectible<'c> for Break {
|
|
||||||
fn collect(&'c self, c: &mut Collector<'c>) {
|
|
||||||
let Self { body } = self;
|
|
||||||
c.collect(body);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<'c> Collectible<'c> for Return {
|
|
||||||
fn collect(&'c self, c: &mut Collector<'c>) {
|
|
||||||
let Self { body } = self;
|
|
||||||
c.collect(body);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<'c> Collectible<'c> for Continue {
|
|
||||||
fn collect(&'c self, _c: &mut Collector<'c>) {}
|
|
||||||
}
|
|
||||||
impl<'c> Collectible<'c> for Literal {
|
|
||||||
fn collect(&'c self, _c: &mut Collector<'c>) {}
|
|
||||||
}
|
|
||||||
impl<'c> Collectible<'c> for Identifier {
|
|
||||||
fn collect(&'c self, c: &mut Collector<'c>) {
|
|
||||||
let Self(name) = self;
|
|
||||||
c.reference(name);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<'c> Collectible<'c> for Param {
|
|
||||||
fn collect(&'c self, c: &mut Collector<'c>) {
|
|
||||||
let Self { mutability: _, name, ty } = self;
|
|
||||||
c.collect(name).collect(ty);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<'c> Collectible<'c> for Ty {
|
|
||||||
fn collect(&'c self, c: &mut Collector<'c>) {
|
|
||||||
let Self { extents, kind } = self;
|
|
||||||
c.location(extents.head).collect(kind);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<'c> Collectible<'c> for TyKind {
|
|
||||||
fn collect(&'c self, c: &mut Collector<'c>) {
|
|
||||||
match self {
|
|
||||||
TyKind::Never => {}
|
|
||||||
TyKind::Empty => {}
|
|
||||||
TyKind::SelfTy => {}
|
|
||||||
TyKind::Path(t) => t.collect(c),
|
|
||||||
TyKind::Tuple(t) => t.collect(c),
|
|
||||||
TyKind::Ref(t) => t.collect(c),
|
|
||||||
TyKind::Fn(t) => t.collect(c),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<'c> Collectible<'c> for Path {
|
|
||||||
fn collect(&'c self, c: &mut Collector<'c>) {
|
|
||||||
let Self { absolute: _, parts } = self;
|
|
||||||
for part in parts {
|
|
||||||
c.collect(part);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<'c> Collectible<'c> for PathPart {
|
|
||||||
fn collect(&'c self, c: &mut Collector<'c>) {
|
|
||||||
match self {
|
|
||||||
PathPart::SuperKw => {}
|
|
||||||
PathPart::SelfKw => {}
|
|
||||||
PathPart::Ident(i) => i.collect(c),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<'c> Collectible<'c> for TyTuple {
|
|
||||||
fn collect(&'c self, c: &mut Collector<'c>) {
|
|
||||||
let Self { types } = self;
|
|
||||||
for ty in types {
|
|
||||||
c.collect(ty);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<'c> Collectible<'c> for TyRef {
|
|
||||||
fn collect(&'c self, c: &mut Collector<'c>) {
|
|
||||||
let Self { count: _, to } = self;
|
|
||||||
c.collect(to);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<'c> Collectible<'c> for TyFn {
|
|
||||||
fn collect(&'c self, c: &mut Collector<'c>) {
|
|
||||||
let Self { args, rety } = self;
|
|
||||||
c.collect(args).collect(rety);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<'c, C: Collectible<'c> + Sized> Collectible<'c> for Vec<C> {
|
|
||||||
fn collect(&'c self, c: &mut Collector<'c>) {
|
|
||||||
for i in self {
|
|
||||||
c.collect(i);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<'c, C: Collectible<'c> + Sized> Collectible<'c> for Option<C> {
|
|
||||||
fn collect(&'c self, c: &mut Collector<'c>) {
|
|
||||||
if let Some(i) = self {
|
|
||||||
c.collect(i);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<'c, C: Collectible<'c>> Collectible<'c> for Box<C> {
|
|
||||||
fn collect(&'c self, c: &mut Collector<'c>) {
|
|
||||||
c.collect(self.as_ref());
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
Loading…
Reference in New Issue
Block a user