1 files changed, 6 insertions, 402 deletions

diff --git a/crates/ra_hir/src/expr.rs b/crates/ra_hir/src/expr.rs
index 53da7f0bf..dd2bae9b4 100644
--- a/crates/ra_hir/src/expr.rs
+++ b/crates/ra_hir/src/expr.rs
@@ -6,29 +6,18 @@ pub(crate) mod validation;
 
 use std::{ops::Index, sync::Arc};
 
-use hir_def::{
-    path::GenericArgs,
-    type_ref::{Mutability, TypeRef},
-};
-use ra_arena::{impl_arena_id, map::ArenaMap, Arena, RawId};
+use ra_arena::{map::ArenaMap, Arena};
 use ra_syntax::{ast, AstPtr};
 use rustc_hash::FxHashMap;
 
-use crate::{
-    db::HirDatabase,
-    ty::primitive::{UncertainFloatTy, UncertainIntTy},
-    DefWithBody, Either, HasSource, Name, Path, Resolver, Source,
-};
+use crate::{db::HirDatabase, DefWithBody, Either, HasSource, Resolver, Source};
 
 pub use self::scope::ExprScopes;
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct ExprId(RawId);
-impl_arena_id!(ExprId);
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct PatId(RawId);
-impl_arena_id!(PatId);
+pub use hir_def::expr::{
+    ArithOp, Array, BinaryOp, BindingAnnotation, CmpOp, Expr, ExprId, Literal, LogicOp, MatchArm,
+    Ordering, Pat, PatId, RecordFieldPat, RecordLitField, Statement, UnaryOp,
+};
 
 /// The body of an item (function, const etc.).
 #[derive(Debug, Eq, PartialEq)]
@@ -187,388 +176,3 @@ impl BodySourceMap {
         self.field_map[&(expr, field)]
     }
 }
-
-#[derive(Debug, Clone, Eq, PartialEq)]
-pub enum Literal {
-    String(String),
-    ByteString(Vec<u8>),
-    Char(char),
-    Bool(bool),
-    Int(u64, UncertainIntTy),
-    Float(u64, UncertainFloatTy), // FIXME: f64 is not Eq
-}
-
-#[derive(Debug, Clone, Eq, PartialEq)]
-pub enum Expr {
-    /// This is produced if syntax tree does not have a required expression piece.
-    Missing,
-    Path(Path),
-    If {
-        condition: ExprId,
-        then_branch: ExprId,
-        else_branch: Option<ExprId>,
-    },
-    Block {
-        statements: Vec<Statement>,
-        tail: Option<ExprId>,
-    },
-    Loop {
-        body: ExprId,
-    },
-    While {
-        condition: ExprId,
-        body: ExprId,
-    },
-    For {
-        iterable: ExprId,
-        pat: PatId,
-        body: ExprId,
-    },
-    Call {
-        callee: ExprId,
-        args: Vec<ExprId>,
-    },
-    MethodCall {
-        receiver: ExprId,
-        method_name: Name,
-        args: Vec<ExprId>,
-        generic_args: Option<GenericArgs>,
-    },
-    Match {
-        expr: ExprId,
-        arms: Vec<MatchArm>,
-    },
-    Continue,
-    Break {
-        expr: Option<ExprId>,
-    },
-    Return {
-        expr: Option<ExprId>,
-    },
-    RecordLit {
-        path: Option<Path>,
-        fields: Vec<RecordLitField>,
-        spread: Option<ExprId>,
-    },
-    Field {
-        expr: ExprId,
-        name: Name,
-    },
-    Await {
-        expr: ExprId,
-    },
-    Try {
-        expr: ExprId,
-    },
-    TryBlock {
-        body: ExprId,
-    },
-    Cast {
-        expr: ExprId,
-        type_ref: TypeRef,
-    },
-    Ref {
-        expr: ExprId,
-        mutability: Mutability,
-    },
-    Box {
-        expr: ExprId,
-    },
-    UnaryOp {
-        expr: ExprId,
-        op: UnaryOp,
-    },
-    BinaryOp {
-        lhs: ExprId,
-        rhs: ExprId,
-        op: Option<BinaryOp>,
-    },
-    Index {
-        base: ExprId,
-        index: ExprId,
-    },
-    Lambda {
-        args: Vec<PatId>,
-        arg_types: Vec<Option<TypeRef>>,
-        body: ExprId,
-    },
-    Tuple {
-        exprs: Vec<ExprId>,
-    },
-    Array(Array),
-    Literal(Literal),
-}
-
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
-pub enum BinaryOp {
-    LogicOp(LogicOp),
-    ArithOp(ArithOp),
-    CmpOp(CmpOp),
-    Assignment { op: Option<ArithOp> },
-}
-
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
-pub enum LogicOp {
-    And,
-    Or,
-}
-
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
-pub enum CmpOp {
-    Eq { negated: bool },
-    Ord { ordering: Ordering, strict: bool },
-}
-
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
-pub enum Ordering {
-    Less,
-    Greater,
-}
-
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
-pub enum ArithOp {
-    Add,
-    Mul,
-    Sub,
-    Div,
-    Rem,
-    Shl,
-    Shr,
-    BitXor,
-    BitOr,
-    BitAnd,
-}
-
-pub use ra_syntax::ast::PrefixOp as UnaryOp;
-#[derive(Debug, Clone, Eq, PartialEq)]
-pub enum Array {
-    ElementList(Vec<ExprId>),
-    Repeat { initializer: ExprId, repeat: ExprId },
-}
-
-#[derive(Debug, Clone, Eq, PartialEq)]
-pub struct MatchArm {
-    pub pats: Vec<PatId>,
-    pub guard: Option<ExprId>,
-    pub expr: ExprId,
-}
-
-#[derive(Debug, Clone, Eq, PartialEq)]
-pub struct RecordLitField {
-    pub name: Name,
-    pub expr: ExprId,
-}
-
-#[derive(Debug, Clone, Eq, PartialEq)]
-pub enum Statement {
-    Let { pat: PatId, type_ref: Option<TypeRef>, initializer: Option<ExprId> },
-    Expr(ExprId),
-}
-
-impl Expr {
-    pub fn walk_child_exprs(&self, mut f: impl FnMut(ExprId)) {
-        match self {
-            Expr::Missing => {}
-            Expr::Path(_) => {}
-            Expr::If { condition, then_branch, else_branch } => {
-                f(*condition);
-                f(*then_branch);
-                if let Some(else_branch) = else_branch {
-                    f(*else_branch);
-                }
-            }
-            Expr::Block { statements, tail } => {
-                for stmt in statements {
-                    match stmt {
-                        Statement::Let { initializer, .. } => {
-                            if let Some(expr) = initializer {
-                                f(*expr);
-                            }
-                        }
-                        Statement::Expr(e) => f(*e),
-                    }
-                }
-                if let Some(expr) = tail {
-                    f(*expr);
-                }
-            }
-            Expr::TryBlock { body } => f(*body),
-            Expr::Loop { body } => f(*body),
-            Expr::While { condition, body } => {
-                f(*condition);
-                f(*body);
-            }
-            Expr::For { iterable, body, .. } => {
-                f(*iterable);
-                f(*body);
-            }
-            Expr::Call { callee, args } => {
-                f(*callee);
-                for arg in args {
-                    f(*arg);
-                }
-            }
-            Expr::MethodCall { receiver, args, .. } => {
-                f(*receiver);
-                for arg in args {
-                    f(*arg);
-                }
-            }
-            Expr::Match { expr, arms } => {
-                f(*expr);
-                for arm in arms {
-                    f(arm.expr);
-                }
-            }
-            Expr::Continue => {}
-            Expr::Break { expr } | Expr::Return { expr } => {
-                if let Some(expr) = expr {
-                    f(*expr);
-                }
-            }
-            Expr::RecordLit { fields, spread, .. } => {
-                for field in fields {
-                    f(field.expr);
-                }
-                if let Some(expr) = spread {
-                    f(*expr);
-                }
-            }
-            Expr::Lambda { body, .. } => {
-                f(*body);
-            }
-            Expr::BinaryOp { lhs, rhs, .. } => {
-                f(*lhs);
-                f(*rhs);
-            }
-            Expr::Index { base, index } => {
-                f(*base);
-                f(*index);
-            }
-            Expr::Field { expr, .. }
-            | Expr::Await { expr }
-            | Expr::Try { expr }
-            | Expr::Cast { expr, .. }
-            | Expr::Ref { expr, .. }
-            | Expr::UnaryOp { expr, .. }
-            | Expr::Box { expr } => {
-                f(*expr);
-            }
-            Expr::Tuple { exprs } => {
-                for expr in exprs {
-                    f(*expr);
-                }
-            }
-            Expr::Array(a) => match a {
-                Array::ElementList(exprs) => {
-                    for expr in exprs {
-                        f(*expr);
-                    }
-                }
-                Array::Repeat { initializer, repeat } => {
-                    f(*initializer);
-                    f(*repeat)
-                }
-            },
-            Expr::Literal(_) => {}
-        }
-    }
-}
-
-/// Explicit binding annotations given in the HIR for a binding. Note
-/// that this is not the final binding *mode* that we infer after type
-/// inference.
-#[derive(Clone, PartialEq, Eq, Debug, Copy)]
-pub enum BindingAnnotation {
-    /// No binding annotation given: this means that the final binding mode
-    /// will depend on whether we have skipped through a `&` reference
-    /// when matching. For example, the `x` in `Some(x)` will have binding
-    /// mode `None`; if you do `let Some(x) = &Some(22)`, it will
-    /// ultimately be inferred to be by-reference.
-    Unannotated,
-
-    /// Annotated with `mut x` -- could be either ref or not, similar to `None`.
-    Mutable,
-
-    /// Annotated as `ref`, like `ref x`
-    Ref,
-
-    /// Annotated as `ref mut x`.
-    RefMut,
-}
-
-impl BindingAnnotation {
-    fn new(is_mutable: bool, is_ref: bool) -> Self {
-        match (is_mutable, is_ref) {
-            (true, true) => BindingAnnotation::RefMut,
-            (false, true) => BindingAnnotation::Ref,
-            (true, false) => BindingAnnotation::Mutable,
-            (false, false) => BindingAnnotation::Unannotated,
-        }
-    }
-}
-
-#[derive(Debug, Clone, Eq, PartialEq)]
-pub struct RecordFieldPat {
-    pub(crate) name: Name,
-    pub(crate) pat: PatId,
-}
-
-/// Close relative to rustc's hir::PatKind
-#[derive(Debug, Clone, Eq, PartialEq)]
-pub enum Pat {
-    Missing,
-    Wild,
-    Tuple(Vec<PatId>),
-    Record {
-        path: Option<Path>,
-        args: Vec<RecordFieldPat>,
-        // FIXME: 'ellipsis' option
-    },
-    Range {
-        start: ExprId,
-        end: ExprId,
-    },
-    Slice {
-        prefix: Vec<PatId>,
-        rest: Option<PatId>,
-        suffix: Vec<PatId>,
-    },
-    Path(Path),
-    Lit(ExprId),
-    Bind {
-        mode: BindingAnnotation,
-        name: Name,
-        subpat: Option<PatId>,
-    },
-    TupleStruct {
-        path: Option<Path>,
-        args: Vec<PatId>,
-    },
-    Ref {
-        pat: PatId,
-        mutability: Mutability,
-    },
-}
-
-impl Pat {
-    pub fn walk_child_pats(&self, mut f: impl FnMut(PatId)) {
-        match self {
-            Pat::Range { .. } | Pat::Lit(..) | Pat::Path(..) | Pat::Wild | Pat::Missing => {}
-            Pat::Bind { subpat, .. } => {
-                subpat.iter().copied().for_each(f);
-            }
-            Pat::Tuple(args) | Pat::TupleStruct { args, .. } => {
-                args.iter().copied().for_each(f);
-            }
-            Pat::Ref { pat, .. } => f(*pat),
-            Pat::Slice { prefix, rest, suffix } => {
-                let total_iter = prefix.iter().chain(rest.iter()).chain(suffix.iter());
-                total_iter.copied().for_each(f);
-            }
-            Pat::Record { args, .. } => {
-                args.iter().map(|f| f.pat).for_each(f);
-            }
-        }
-    }
-}