diff options
Diffstat (limited to 'dhall/src/phase')
-rw-r--r-- | dhall/src/phase/binary.rs | 4 | ||||
-rw-r--r-- | dhall/src/phase/mod.rs | 41 | ||||
-rw-r--r-- | dhall/src/phase/normalize.rs | 14 | ||||
-rw-r--r-- | dhall/src/phase/parse.rs | 8 | ||||
-rw-r--r-- | dhall/src/phase/resolve.rs | 8 | ||||
-rw-r--r-- | dhall/src/phase/typecheck.rs | 12 |
6 files changed, 41 insertions, 46 deletions
diff --git a/dhall/src/phase/binary.rs b/dhall/src/phase/binary.rs index 36dd471..3746635 100644 --- a/dhall/src/phase/binary.rs +++ b/dhall/src/phase/binary.rs @@ -11,14 +11,14 @@ use dhall_syntax::{ use crate::error::{DecodeError, EncodeError}; use crate::phase::DecodedSubExpr; -pub fn decode(data: &[u8]) -> Result<DecodedSubExpr, DecodeError> { +pub(crate) fn decode(data: &[u8]) -> Result<DecodedSubExpr, DecodeError> { match serde_cbor::de::from_slice(data) { Ok(v) => cbor_value_to_dhall(&v), Err(e) => Err(DecodeError::CBORError(e)), } } -pub fn encode<E>(expr: &SubExpr<E>) -> Result<Vec<u8>, EncodeError> { +pub(crate) fn encode<E>(expr: &SubExpr<E>) -> Result<Vec<u8>, EncodeError> { serde_cbor::ser::to_vec(&Serialize::Expr(expr)) .map_err(|e| EncodeError::CBORError(e)) } diff --git a/dhall/src/phase/mod.rs b/dhall/src/phase/mod.rs index 2700e99..778f990 100644 --- a/dhall/src/phase/mod.rs +++ b/dhall/src/phase/mod.rs @@ -50,11 +50,9 @@ impl Parsed { pub fn parse_str(s: &str) -> Result<Parsed, Error> { parse::parse_str(s) } - #[allow(dead_code)] pub fn parse_binary_file(f: &Path) -> Result<Parsed, Error> { parse::parse_binary_file(f) } - #[allow(dead_code)] pub fn parse_binary(data: &[u8]) -> Result<Parsed, Error> { parse::parse_binary(data) } @@ -62,12 +60,10 @@ impl Parsed { pub fn resolve(self) -> Result<Resolved, ImportError> { resolve::resolve(self) } - #[allow(dead_code)] pub fn skip_resolve(self) -> Result<Resolved, ImportError> { resolve::skip_resolve_expr(self) } - #[allow(dead_code)] pub fn encode(&self) -> Result<Vec<u8>, EncodeError> { crate::phase::binary::encode(&self.0) } @@ -82,7 +78,7 @@ impl Resolved { } /// Pretends this expression has been typechecked. Use with care. #[allow(dead_code)] - pub fn skip_typecheck(self) -> Typed { + pub(crate) fn skip_typecheck(self) -> Typed { typecheck::skip_typecheck(self) } } @@ -101,29 +97,29 @@ impl Typed { Normalized(self) } - pub fn from_thunk_and_type(th: Thunk, t: Type) -> Self { + pub(crate) fn from_thunk_and_type(th: Thunk, t: Type) -> Self { Typed(TypedThunk::from_thunk_and_type(th, t)) } - pub fn from_thunk_untyped(th: Thunk) -> Self { + pub(crate) fn from_thunk_untyped(th: Thunk) -> Self { Typed(TypedThunk::from_thunk_untyped(th)) } - pub fn from_const(c: Const) -> Self { + pub(crate) fn from_const(c: Const) -> Self { Typed(TypedThunk::from_const(c)) } pub fn from_value_untyped(v: Value) -> Self { Typed(TypedThunk::from_value_untyped(v)) } - pub fn from_typethunk(th: TypedThunk) -> Self { + pub(crate) fn from_typethunk(th: TypedThunk) -> Self { Typed(th) } - pub fn to_value(&self) -> Value { + pub(crate) fn to_value(&self) -> Value { self.0.to_value() } pub fn to_expr(&self) -> NormalizedSubExpr { self.0.to_expr() } - pub fn to_expr_alpha(&self) -> NormalizedSubExpr { + pub(crate) fn to_expr_alpha(&self) -> NormalizedSubExpr { self.0.to_expr_alpha() } pub fn to_thunk(&self) -> Thunk { @@ -134,24 +130,24 @@ impl Typed { self.clone() } // Deprecated - pub fn into_type(self) -> Type { + pub(crate) fn into_type(self) -> Type { self } - pub fn into_typethunk(self) -> TypedThunk { + pub(crate) fn into_typethunk(self) -> TypedThunk { self.0 } - pub fn to_normalized(&self) -> Normalized { + pub(crate) fn to_normalized(&self) -> Normalized { self.clone().normalize() } - pub fn as_const(&self) -> Option<Const> { + pub(crate) fn as_const(&self) -> Option<Const> { self.0.as_const() } - pub fn normalize_mut(&mut self) { + pub(crate) fn normalize_mut(&mut self) { self.0.normalize_mut() } - pub fn get_type(&self) -> Result<Cow<'_, Type>, TypeError> { + pub(crate) fn get_type(&self) -> Result<Cow<'_, Type>, TypeError> { self.0.get_type() } } @@ -161,22 +157,21 @@ impl Normalized { crate::phase::binary::encode(&self.to_expr()) } - #[allow(dead_code)] - pub fn to_expr(&self) -> NormalizedSubExpr { + pub(crate) fn to_expr(&self) -> NormalizedSubExpr { self.0.to_expr() } #[allow(dead_code)] - pub fn to_expr_alpha(&self) -> NormalizedSubExpr { + pub(crate) fn to_expr_alpha(&self) -> NormalizedSubExpr { self.0.to_expr_alpha() } #[allow(dead_code)] - pub fn to_type(&self) -> Type { + pub(crate) fn to_type(&self) -> Type { self.0.to_type() } - pub fn to_value(&self) -> Value { + pub(crate) fn to_value(&self) -> Value { self.0.to_value() } - pub fn into_typed(self) -> Typed { + pub(crate) fn into_typed(self) -> Typed { self.0 } } diff --git a/dhall/src/phase/normalize.rs b/dhall/src/phase/normalize.rs index 02406f2..fd0197d 100644 --- a/dhall/src/phase/normalize.rs +++ b/dhall/src/phase/normalize.rs @@ -11,8 +11,8 @@ use crate::core::value::Value; use crate::core::var::{Shift, Subst}; use crate::phase::{Normalized, NormalizedSubExpr, ResolvedSubExpr, Typed}; -pub type InputSubExpr = ResolvedSubExpr; -pub type OutputSubExpr = NormalizedSubExpr; +pub(crate) type InputSubExpr = ResolvedSubExpr; +pub(crate) type OutputSubExpr = NormalizedSubExpr; // Ad-hoc macro to help construct closures macro_rules! make_closure { @@ -57,7 +57,7 @@ macro_rules! make_closure { } #[allow(clippy::cognitive_complexity)] -pub fn apply_builtin(b: Builtin, args: Vec<Thunk>) -> Value { +pub(crate) fn apply_builtin(b: Builtin, args: Vec<Thunk>) -> Value { use dhall_syntax::Builtin::*; use Value::*; @@ -315,7 +315,7 @@ pub fn apply_builtin(b: Builtin, args: Vec<Thunk>) -> Value { } } -pub fn apply_any(f: Thunk, a: Thunk) -> Value { +pub(crate) fn apply_any(f: Thunk, a: Thunk) -> Value { let fallback = |f: Thunk, a: Thunk| Value::PartialExpr(ExprF::App(f, a)); let f_borrow = f.as_value(); @@ -339,7 +339,7 @@ pub fn apply_any(f: Thunk, a: Thunk) -> Value { } } -pub fn squash_textlit( +pub(crate) fn squash_textlit( elts: impl Iterator<Item = InterpolatedTextContents<Thunk>>, ) -> Vec<InterpolatedTextContents<Thunk>> { use std::mem::replace; @@ -382,7 +382,7 @@ pub fn squash_textlit( } /// Reduces the imput expression to a Value. Evaluates as little as possible. -pub fn normalize_whnf(ctx: NormalizationContext, expr: InputSubExpr) -> Value { +pub(crate) fn normalize_whnf(ctx: NormalizationContext, expr: InputSubExpr) -> Value { match expr.as_ref() { ExprF::Embed(e) => return e.to_value(), ExprF::Var(v) => return ctx.lookup(v), @@ -649,7 +649,7 @@ fn apply_binop<'a>(o: BinOp, x: &'a Thunk, y: &'a Thunk) -> Option<Ret<'a>> { }) } -pub fn normalize_one_layer(expr: ExprF<Thunk, Normalized>) -> Value { +pub(crate) fn normalize_one_layer(expr: ExprF<Thunk, Normalized>) -> Value { use Value::{ AppliedBuiltin, BoolLit, DoubleLit, EmptyListLit, IntegerLit, Lam, NEListLit, NEOptionalLit, NaturalLit, Pi, RecordLit, RecordType, diff --git a/dhall/src/phase/parse.rs b/dhall/src/phase/parse.rs index 9f3f2f4..540ceea 100644 --- a/dhall/src/phase/parse.rs +++ b/dhall/src/phase/parse.rs @@ -8,7 +8,7 @@ use crate::error::Error; use crate::phase::resolve::ImportRoot; use crate::phase::Parsed; -pub fn parse_file(f: &Path) -> Result<Parsed, Error> { +pub(crate) fn parse_file(f: &Path) -> Result<Parsed, Error> { let mut buffer = String::new(); File::open(f)?.read_to_string(&mut buffer)?; let expr = parse_expr(&*buffer)?; @@ -16,19 +16,19 @@ pub fn parse_file(f: &Path) -> Result<Parsed, Error> { Ok(Parsed(expr, root)) } -pub fn parse_str(s: &str) -> Result<Parsed, Error> { +pub(crate) fn parse_str(s: &str) -> Result<Parsed, Error> { let expr = parse_expr(s)?; let root = ImportRoot::LocalDir(std::env::current_dir()?); Ok(Parsed(expr, root)) } -pub fn parse_binary(data: &[u8]) -> Result<Parsed, Error> { +pub(crate) fn parse_binary(data: &[u8]) -> Result<Parsed, Error> { let expr = crate::phase::binary::decode(data)?; let root = ImportRoot::LocalDir(std::env::current_dir()?); Ok(Parsed(expr, root)) } -pub fn parse_binary_file(f: &Path) -> Result<Parsed, Error> { +pub(crate) fn parse_binary_file(f: &Path) -> Result<Parsed, Error> { let mut buffer = Vec::new(); File::open(f)?.read_to_end(&mut buffer)?; let expr = crate::phase::binary::decode(&buffer)?; diff --git a/dhall/src/phase/resolve.rs b/dhall/src/phase/resolve.rs index dabecf2..27ae7a3 100644 --- a/dhall/src/phase/resolve.rs +++ b/dhall/src/phase/resolve.rs @@ -8,13 +8,13 @@ type Import = dhall_syntax::Import<NormalizedSubExpr>; /// A root from which to resolve relative imports. #[derive(Debug, Clone, PartialEq, Eq)] -pub enum ImportRoot { +pub(crate) enum ImportRoot { LocalDir(PathBuf), } type ImportCache = HashMap<Import, Normalized>; -pub type ImportStack = Vec<Import>; +pub(crate) type ImportStack = Vec<Import>; fn resolve_import( import: &Import, @@ -90,11 +90,11 @@ fn do_resolve_expr( Ok(Resolved(expr)) } -pub fn resolve(e: Parsed) -> Result<Resolved, ImportError> { +pub(crate) fn resolve(e: Parsed) -> Result<Resolved, ImportError> { do_resolve_expr(e, &mut HashMap::new(), &Vec::new()) } -pub fn skip_resolve_expr( +pub(crate) fn skip_resolve_expr( Parsed(expr, _root): Parsed, ) -> Result<Resolved, ImportError> { let resolve = |import: &Import| -> Result<Normalized, ImportError> { diff --git a/dhall/src/phase/typecheck.rs b/dhall/src/phase/typecheck.rs index 5eab8da..56fb5ed 100644 --- a/dhall/src/phase/typecheck.rs +++ b/dhall/src/phase/typecheck.rs @@ -147,7 +147,7 @@ fn function_check(a: Const, b: Const) -> Const { } } -pub fn type_of_const(c: Const) -> Result<Type, TypeError> { +pub(crate) fn type_of_const(c: Const) -> Result<Type, TypeError> { match c { Const::Type => Ok(Type::from_const(Const::Kind)), Const::Kind => Ok(Type::from_const(Const::Sort)), @@ -300,14 +300,14 @@ fn type_of_builtin<E>(b: Builtin) -> Expr<E> { /// Takes an expression that is meant to contain a Type /// and turn it into a type, typechecking it along the way. -pub fn mktype( +pub(crate) fn mktype( ctx: &TypecheckContext, e: SubExpr<Normalized>, ) -> Result<Type, TypeError> { Ok(type_with(ctx, e)?.to_type()) } -pub fn builtin_to_type(b: Builtin) -> Result<Type, TypeError> { +pub(crate) fn builtin_to_type(b: Builtin) -> Result<Type, TypeError> { mktype(&TypecheckContext::new(), SubExpr::from_builtin(b)) } @@ -1009,15 +1009,15 @@ fn type_of(e: SubExpr<Normalized>) -> Result<Typed, TypeError> { Ok(e) } -pub fn typecheck(e: Resolved) -> Result<Typed, TypeError> { +pub(crate) fn typecheck(e: Resolved) -> Result<Typed, TypeError> { type_of(e.0) } -pub fn typecheck_with(e: Resolved, ty: &Type) -> Result<Typed, TypeError> { +pub(crate) fn typecheck_with(e: Resolved, ty: &Type) -> Result<Typed, TypeError> { let expr: SubExpr<_> = e.0; let ty: SubExpr<_> = ty.to_expr(); type_of(expr.rewrap(ExprF::Annot(expr.clone(), ty))) } -pub fn skip_typecheck(e: Resolved) -> Typed { +pub(crate) fn skip_typecheck(e: Resolved) -> Typed { Typed::from_thunk_untyped(Thunk::new(NormalizationContext::new(), e.0)) } |