Move contents of dhall_syntax to dhall

1 files changed, 14 insertions, 14 deletions

diff --git a/dhall_syntax/src/parser.rs b/dhall/src/syntax/parser.rs
index 044d3f1..2f589fe 100644
--- a/dhall_syntax/src/parser.rs
+++ b/dhall/src/syntax/parser.rs
@@ -5,9 +5,9 @@ use std::rc::Rc;
 
 use pest_consume::{match_nodes, Parser};
 
-use crate::map::{DupTreeMap, DupTreeSet};
-use crate::ExprF::*;
-use crate::*;
+use crate::syntax::map::{DupTreeMap, DupTreeSet};
+use crate::syntax::ExprF::*;
+use crate::syntax::*;
 
 // This file consumes the parse tree generated by pest and turns it into
 // our own AST. All those custom macros should eventually moved into
@@ -28,9 +28,9 @@ enum Selector<E> {
     ProjectionByExpr(Expr<E>),
 }
 
-impl crate::Builtin {
+impl crate::syntax::Builtin {
     pub fn parse(s: &str) -> Option<Self> {
-        use crate::Builtin::*;
+        use crate::syntax::Builtin::*;
         match s {
             "Bool" => Some(Bool),
             "Natural" => Some(Natural),
@@ -146,7 +146,7 @@ lazy_static::lazy_static! {
 }
 
 #[derive(Parser)]
-#[grammar = "dhall.pest"]
+#[grammar = "../../dhall_syntax/src/dhall.pest"]
 struct DhallParser;
 
 #[pest_consume::parser(parser = DhallParser, rule = Rule)]
@@ -328,14 +328,14 @@ impl DhallParser {
     #[alias(expression)]
     fn builtin<E: Clone>(input: ParseInput) -> ParseResult<Expr<E>> {
         let s = input.as_str();
-        let e = match crate::Builtin::parse(s) {
+        let e = match crate::syntax::Builtin::parse(s) {
             Some(b) => Builtin(b),
             None => match s {
                 "True" => BoolLit(true),
                 "False" => BoolLit(false),
-                "Type" => Const(crate::Const::Type),
-                "Kind" => Const(crate::Const::Kind),
-                "Sort" => Const(crate::Const::Sort),
+                "Type" => Const(crate::syntax::Const::Type),
+                "Kind" => Const(crate::syntax::Const::Kind),
+                "Sort" => Const(crate::syntax::Const::Sort),
                 _ => {
                     Err(input.error(format!("Unrecognized builtin: '{}'", s)))?
                 }
@@ -575,8 +575,8 @@ impl DhallParser {
 
     fn import_hashed<E: Clone>(
         input: ParseInput,
-    ) -> ParseResult<crate::Import<Expr<E>>> {
-        use crate::Import;
+    ) -> ParseResult<crate::syntax::Import<Expr<E>>> {
+        use crate::syntax::Import;
         let mode = ImportMode::Code;
         Ok(match_nodes!(input.into_children();
             [import_type(location)] => Import { mode, location, hash: None },
@@ -595,7 +595,7 @@ impl DhallParser {
 
     #[alias(expression)]
     fn import<E: Clone>(input: ParseInput) -> ParseResult<Expr<E>> {
-        use crate::Import;
+        use crate::syntax::Import;
         let import = match_nodes!(input.children();
             [import_hashed(imp)] => {
                 Import { mode: ImportMode::Code, ..imp }
@@ -699,7 +699,7 @@ impl DhallParser {
         op: ParseInput,
         r: Expr<E>,
     ) -> ParseResult<Expr<E>> {
-        use crate::BinOp::*;
+        use crate::syntax::BinOp::*;
         use Rule::*;
         let op = match op.as_rule() {
             import_alt => ImportAlt,