Collapse bound and invariant::natural into natural.

This change collapses modules concerning natural quantities and bounds
into the `token::variance::natural` module. Misused `macro_export`
attributes have also been removed (macros are not meant to be exported
in public APIs).

Author: olson-sean-k

src/token/mod.rs

@@ -15,21 +15,17 @@ use std::str;
 use crate::diagnostics::{Span, Spanned};
 use crate::query::When;
 use crate::token::variance::invariant::{
-    BoundaryTerm, IntoNominalText, IntoStructuralText, One, Zero,
+    BoundaryTerm, Finalize, IntoNominalText, IntoStructuralText, InvariantTerm, One, Zero,
 };
 use crate::token::variance::ops;
 use crate::token::variance::{TreeExhaustiveness, TreeVariance, VarianceFold, VarianceTerm};
 use crate::token::walk::{BranchFold, Fold, FoldMap, Starting, TokenEntry};
 use crate::{StrExt as _, PATHS_ARE_CASE_INSENSITIVE};
 
 pub use crate::token::parse::{parse, ParseError, ROOT_SEPARATOR_EXPRESSION};
-pub use crate::token::variance::bound::{
-    BoundedVariantRange, Boundedness, NaturalRange, VariantRange,
-};
-pub use crate::token::variance::invariant::{
-    Breadth, Depth, Finalize, Invariant, InvariantTerm, Size, Text,
-};
-pub use crate::token::variance::{TokenVariance, Variance};
+pub use crate::token::variance::invariant::{Breadth, Depth, Invariant, Size, Text};
+pub use crate::token::variance::natural::{BoundedVariantRange, NaturalRange, VariantRange};
+pub use crate::token::variance::{Boundedness, TokenVariance, Variance};
 
 // TODO: Tree representations of expressions are intrusive and only differ in their annotations.
 //       This supports some distinctions between tree types, but greatly limits the ability to

src/token/variance/invariant/mod.rs

@@ -1,14 +1,14 @@
-mod natural;
 mod term;
 mod text;
 
 use std::num::NonZeroUsize;
 
-use crate::token::variance::bound::{BoundedVariantRange, Boundedness, OpenedUpperBound};
-use crate::token::variance::ops::{Conjunction, Disjunction, Product};
-use crate::token::variance::TokenVariance;
+use crate::token::variance::natural::{
+    define_natural_invariant, BoundedVariantRange, OpenedUpperBound,
+};
+use crate::token::variance::ops::{self, Conjunction, Disjunction, Product};
+use crate::token::variance::{Boundedness, TokenVariance};
 
-pub use crate::token::variance::invariant::natural::{Depth, Size};
 pub use crate::token::variance::invariant::term::{BoundaryTerm, SeparatedTerm, Termination};
 pub use crate::token::variance::invariant::text::{IntoNominalText, IntoStructuralText, Text};
 
@@ -38,6 +38,59 @@ pub trait Invariant: Sized + Zero {
     fn into_lower_bound(self) -> Boundedness<Self::Bound>;
 }
 
+#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
+pub struct UnitBound;
+
+impl<T> Conjunction<T> for UnitBound {
+    type Output = Self;
+
+    fn conjunction(self, _: T) -> Self::Output {
+        self
+    }
+}
+
+impl Disjunction for UnitBound {
+    type Output = Boundedness<Self>;
+
+    fn disjunction(self, _: Self) -> Self::Output {
+        self.into()
+    }
+}
+
+impl From<()> for UnitBound {
+    fn from(_: ()) -> Self {
+        UnitBound
+    }
+}
+
+impl From<BoundedVariantRange> for UnitBound {
+    fn from(_: BoundedVariantRange) -> Self {
+        UnitBound
+    }
+}
+
+impl OpenedUpperBound for UnitBound {
+    fn opened_upper_bound(self) -> Boundedness<Self> {
+        UnitBound.into()
+    }
+}
+
+impl Product<BoundedVariantRange> for UnitBound {
+    type Output = Boundedness<Self>;
+
+    fn product(self, _: BoundedVariantRange) -> Self::Output {
+        self.into()
+    }
+}
+
+impl Product<NonZeroUsize> for Boundedness<UnitBound> {
+    type Output = Self;
+
+    fn product(self, _: NonZeroUsize) -> Self::Output {
+        self
+    }
+}
+
 // Breadth is the maximum size (UTF-8 bytes) of component text in a glob expression. For example,
 // the breadth of `{a/,a/b/}<c/d:2>` is two (bytes).
 //
@@ -82,55 +135,39 @@ impl Invariant for Breadth {
     }
 }
 
-#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
-pub struct UnitBound;
-
-impl<T> Conjunction<T> for UnitBound {
-    type Output = Self;
-
-    fn conjunction(self, _: T) -> Self::Output {
-        self
-    }
-}
-
-impl Disjunction for UnitBound {
-    type Output = Boundedness<Self>;
-
-    fn disjunction(self, _: Self) -> Self::Output {
-        self.into()
-    }
-}
+define_natural_invariant!(
+    /// Depth of a glob expression.
+    Depth => BoundaryTerm,
+);
 
-impl From<()> for UnitBound {
-    fn from(_: ()) -> Self {
-        UnitBound
+impl TokenVariance<Depth> {
+    pub fn is_exhaustive(&self) -> bool {
+        !self.has_upper_bound()
     }
 }
 
-impl From<BoundedVariantRange> for UnitBound {
-    fn from(_: BoundedVariantRange) -> Self {
-        UnitBound
+impl BoundaryTerm<Depth> {
+    pub fn is_exhaustive(&self) -> bool {
+        self.clone().finalize().is_exhaustive()
     }
 }
 
-impl OpenedUpperBound for UnitBound {
-    fn opened_upper_bound(self) -> Boundedness<Self> {
-        UnitBound.into()
-    }
-}
+impl Finalize for SeparatedTerm<TokenVariance<Depth>> {
+    type Output = TokenVariance<Depth>;
 
-impl Product<BoundedVariantRange> for UnitBound {
-    type Output = Boundedness<Self>;
+    fn finalize(self) -> Self::Output {
+        use Termination::{Closed, Open};
 
-    fn product(self, _: BoundedVariantRange) -> Self::Output {
-        self.into()
+        let SeparatedTerm(termination, term) = self;
+        match termination {
+            Open => ops::conjunction(term, One::one()),
+            Closed => term.map_invariant(|term| term.map(|term| term.saturating_sub(1))),
+            _ => term,
+        }
     }
 }
 
-impl Product<NonZeroUsize> for Boundedness<UnitBound> {
-    type Output = Self;
-
-    fn product(self, _: NonZeroUsize) -> Self::Output {
-        self
-    }
-}
+define_natural_invariant!(
+    /// Size of a glob expression.
+    Size,
+);

src/token/variance/invariant/natural.rs

@@ -2,10 +2,9 @@ use itertools::Itertools;
 use std::collections::HashSet;
 use std::hash::Hash;
 
-use crate::token::variance::bound::Boundedness;
 use crate::token::variance::invariant::{Finalize, Invariant, One, Zero};
 use crate::token::variance::ops::{self, Conjunction, Disjunction, Product};
-use crate::token::variance::{TokenVariance, Variance};
+use crate::token::variance::{Boundedness, TokenVariance, Variance};
 use crate::token::Composition;
 
 pub type BoundaryTerm<T> = TreeTerm<SeparatedTerm<TokenVariance<T>>>;

src/token/variance/invariant/term.rs

@@ -3,10 +3,10 @@ use std::collections::VecDeque;
 use std::num::NonZeroUsize;
 
 use crate::encode;
-use crate::token::variance::bound::{Boundedness, VariantRange};
 use crate::token::variance::invariant::{Invariant, UnitBound, Zero};
+use crate::token::variance::natural::VariantRange;
 use crate::token::variance::ops::{self, Conjunction, Disjunction, Product};
-use crate::token::variance::{TokenVariance, Variance};
+use crate::token::variance::{Boundedness, TokenVariance, Variance};
 use crate::PATHS_ARE_CASE_INSENSITIVE;
 
 use Fragment::{Nominal, Structural};