remove crate_visibility_modifier

Author: nikomatsakis

chalk-engine/src/context.rs

@@ -1,10 +1,10 @@
-use crate::fallible::Fallible;
-use crate::hh::HhGoal;
-use crate::{DelayedLiteral, ExClause, SimplifiedAnswer};
+use fallible::Fallible;
+use hh::HhGoal;
+use {DelayedLiteral, ExClause, SimplifiedAnswer};
 use std::fmt::Debug;
 use std::hash::Hash;
 
-crate mod prelude;
+pub(crate) mod prelude;
 
 /// The "context" in which the SLG solver operates. It defines all the
 /// types that the SLG solver may need to refer to, as well as a few

chalk-engine/src/context/prelude.rs

@@ -1,8 +1,8 @@
 #![allow(unused_imports)] // rustc bug
 
-crate use super::Context;
-crate use super::ContextOps;
-crate use super::AggregateOps;
-crate use super::ResolventOps;
-crate use super::TruncateOps;
-crate use super::InferenceTable;
+pub(crate) use super::Context;
+pub(crate) use super::ContextOps;
+pub(crate) use super::AggregateOps;
+pub(crate) use super::ResolventOps;
+pub(crate) use super::TruncateOps;
+pub(crate) use super::InferenceTable;

chalk-engine/src/forest.rs

@@ -1,16 +1,16 @@
-use crate::{DepthFirstNumber, SimplifiedAnswer, TableIndex};
-use crate::context::prelude::*;
-use crate::context::AnswerStream;
-use crate::logic::RootSearchFail;
-use crate::stack::{Stack, StackIndex};
-use crate::tables::Tables;
-use crate::table::{Answer, AnswerIndex};
+use {DepthFirstNumber, SimplifiedAnswer, TableIndex};
+use context::prelude::*;
+use context::AnswerStream;
+use logic::RootSearchFail;
+use stack::{Stack, StackIndex};
+use tables::Tables;
+use table::{Answer, AnswerIndex};
 
 pub struct Forest<C: Context, CO: ContextOps<C>> {
     #[allow(dead_code)]
-    crate context: CO,
-    crate tables: Tables<C>,
-    crate stack: Stack,
+    pub(crate) context: CO,
+    pub(crate) tables: Tables<C>,
+    pub(crate) stack: Stack,
 
     dfn: DepthFirstNumber,
 }

chalk-engine/src/hh.rs

@@ -1,4 +1,4 @@
-use crate::context::Context;
+use context::Context;
 
 #[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
 /// A general goal; this is the full range of questions you can pose to Chalk.

chalk-engine/src/lib.rs

@@ -49,8 +49,6 @@
 //! - HH: Hereditary harrop predicates. What Chalk deals in.
 //!   Popularized by Lambda Prolog.
 
-#![feature(crate_in_paths)]
-#![feature(crate_visibility_modifier)]
 #![feature(in_band_lifetimes)]
 #![feature(step_trait)]
 #![feature(non_modrs_mods)]
@@ -63,7 +61,7 @@ extern crate stacker;
 
 extern crate rustc_hash;
 
-use crate::context::Context;
+use context::Context;
 use rustc_hash::FxHashSet;
 use std::cmp::min;
 use std::usize;

chalk-engine/src/logic.rs

@@ -1,12 +1,12 @@
-use crate::{DelayedLiteral, DelayedLiteralSet, DepthFirstNumber, ExClause, Literal, Minimums,
+use {DelayedLiteral, DelayedLiteralSet, DepthFirstNumber, ExClause, Literal, Minimums,
             TableIndex};
-use crate::fallible::NoSolution;
-use crate::context::{WithInstantiatedExClause, WithInstantiatedUCanonicalGoal, prelude::*};
-use crate::forest::Forest;
-use crate::hh::HhGoal;
-use crate::stack::StackIndex;
-use crate::strand::{CanonicalStrand, SelectedSubgoal, Strand};
-use crate::table::{Answer, AnswerIndex};
+use fallible::NoSolution;
+use context::{WithInstantiatedExClause, WithInstantiatedUCanonicalGoal, prelude::*};
+use forest::Forest;
+use hh::HhGoal;
+use stack::StackIndex;
+use strand::{CanonicalStrand, SelectedSubgoal, Strand};
+use table::{Answer, AnswerIndex};
 use rustc_hash::FxHashSet;
 use std::marker::PhantomData;
 use std::mem;
@@ -184,7 +184,7 @@ impl<C: Context, CO: ContextOps<C>> Forest<C, CO> {
         result.map(|()| EnsureSuccess::AnswerAvailable)
     }
 
-    crate fn answer(&self, table: TableIndex, answer: AnswerIndex) -> &Answer<C> {
+    pub(crate) fn answer(&self, table: TableIndex, answer: AnswerIndex) -> &Answer<C> {
         self.tables[table].answer(answer).unwrap()
     }
 
@@ -692,7 +692,7 @@ impl<C: Context, CO: ContextOps<C>> Forest<C, CO> {
     /// In terms of the NFTD paper, creating a new table corresponds
     /// to the *New Subgoal* step as well as the *Program Clause
     /// Resolution* steps.
-    crate fn get_or_create_table_for_ucanonical_goal(
+    pub(crate) fn get_or_create_table_for_ucanonical_goal(
         &mut self,
         goal: C::UCanonicalGoalInEnvironment,
     ) -> TableIndex {
@@ -1167,7 +1167,7 @@ impl<C: Context, CO: ContextOps<C>> Forest<C, CO> {
         depth: StackIndex,
         strand: Strand<'_, C, impl Context>,
     ) -> StrandResult<C, ()> {
-        crate::maybe_grow_stack(|| self.pursue_strand(depth, strand))
+        ::maybe_grow_stack(|| self.pursue_strand(depth, strand))
     }
 
     /// Invoked when we have found a successful answer to the given

chalk-engine/src/simplify.rs

@@ -1,8 +1,8 @@
-use crate::fallible::Fallible;
-use crate::{ExClause, Literal};
-use crate::forest::Forest;
-use crate::hh::HhGoal;
-use crate::context::prelude::*;
+use fallible::Fallible;
+use {ExClause, Literal};
+use forest::Forest;
+use hh::HhGoal;
+use context::prelude::*;
 
 impl<C: Context, CO: ContextOps<C>> Forest<C, CO> {
     /// Simplifies an HH goal into a series of positive domain goals

chalk-engine/src/stack.rs

@@ -1,9 +1,9 @@
-use crate::{DepthFirstNumber, TableIndex};
+use {DepthFirstNumber, TableIndex};
 use std::ops::{Index, IndexMut, Range};
 
 /// See `Forest`.
 #[derive(Default)]
-crate struct Stack {
+pub(crate) struct Stack {
     /// Stack: as described above, stores the in-progress goals.
     stack: Vec<StackEntry>,
 }
@@ -13,12 +13,12 @@ crate struct Stack {
 /// table is completely evaluated, it may be popped from the stack,
 /// and hence no longer have a stack index.
 index_struct! {
-    crate struct StackIndex {
+    pub(crate) struct StackIndex {
         value: usize,
     }
 }
 
-crate struct StackEntry {
+pub(crate) struct StackEntry {
     /// The goal G from the stack entry `A :- G` represented here.
     pub(super) table: TableIndex,
 

chalk-engine/src/strand.rs

@@ -1,39 +1,39 @@
 use std::fmt::{Debug, Error, Formatter};
-use crate::{ExClause, TableIndex};
-use crate::context::{Context, InferenceTable};
-use crate::table::AnswerIndex;
+use {ExClause, TableIndex};
+use context::{Context, InferenceTable};
+use table::AnswerIndex;
 
 #[derive(Debug)]
-crate struct CanonicalStrand<C: Context> {
+pub(crate) struct CanonicalStrand<C: Context> {
     pub(super) canonical_ex_clause: C::CanonicalExClause,
 
     /// Index into `ex_clause.subgoals`.
-    crate selected_subgoal: Option<SelectedSubgoal<C>>,
+    pub(crate) selected_subgoal: Option<SelectedSubgoal<C>>,
 }
 
-crate struct Strand<'table, C: Context + 'table, I: Context + 'table> {
-    crate infer: &'table mut dyn InferenceTable<C, I>,
+pub(crate) struct Strand<'table, C: Context + 'table, I: Context + 'table> {
+    pub(crate) infer: &'table mut dyn InferenceTable<C, I>,
 
     pub(super) ex_clause: ExClause<I>,
 
     /// Index into `ex_clause.subgoals`.
-    crate selected_subgoal: Option<SelectedSubgoal<C>>,
+    pub(crate) selected_subgoal: Option<SelectedSubgoal<C>>,
 }
 
 #[derive(Clone, Debug)]
-crate struct SelectedSubgoal<C: Context> {
+pub(crate) struct SelectedSubgoal<C: Context> {
     /// The index of the subgoal in `ex_clause.subgoals`
-    crate subgoal_index: usize,
+    pub(crate) subgoal_index: usize,
 
     /// The index of the table that we created or found for this subgoal
     pub(super) subgoal_table: TableIndex,
 
     /// Index of the answer we should request next from the table
-    crate answer_index: AnswerIndex,
+    pub(crate) answer_index: AnswerIndex,
 
     /// Maps the universes of the subgoal to the canonical universes
     /// used in the table
-    crate universe_map: C::UniverseMap,
+    pub(crate) universe_map: C::UniverseMap,
 }
 
 impl<'table, C: Context, I: Context> Debug for Strand<'table, C, I> {

chalk-engine/src/table.rs

@@ -1,19 +1,19 @@
-use crate::{DelayedLiteralSet, DelayedLiteralSets};
-use crate::context::prelude::*;
-use crate::strand::CanonicalStrand;
+use {DelayedLiteralSet, DelayedLiteralSets};
+use context::prelude::*;
+use strand::CanonicalStrand;
 use rustc_hash::FxHashMap;
 use std::collections::VecDeque;
 use std::collections::hash_map::Entry;
 use std::mem;
 
-crate struct Table<C: Context> {
+pub(crate) struct Table<C: Context> {
     /// The goal this table is trying to solve (also the key to look
     /// it up).
-    crate table_goal: C::UCanonicalGoalInEnvironment,
+    pub(crate) table_goal: C::UCanonicalGoalInEnvironment,
 
     /// A goal is coinductive if it can assume itself to be true, more
     /// or less. This is true for auto traits.
-    crate coinductive_goal: bool,
+    pub(crate) coinductive_goal: bool,
 
     /// Stores the answers that we have found thus far. When we get a request
     /// for an answer N, we will first check this vector.
@@ -32,7 +32,7 @@ crate struct Table<C: Context> {
 }
 
 index_struct! {
-    crate struct AnswerIndex {
+    pub(crate) struct AnswerIndex {
         value: usize,
     }
 }
@@ -43,12 +43,12 @@ index_struct! {
 /// a substitution
 #[derive(Clone, Debug)]
 pub struct Answer<C: Context> {
-    crate subst: C::CanonicalConstrainedSubst,
-    crate delayed_literals: DelayedLiteralSet<C>,
+    pub(crate) subst: C::CanonicalConstrainedSubst,
+    pub(crate) delayed_literals: DelayedLiteralSet<C>,
 }
 
 impl<C: Context> Table<C> {
-    crate fn new(table_goal: C::UCanonicalGoalInEnvironment, coinductive_goal: bool) -> Table<C> {
+    pub(crate) fn new(table_goal: C::UCanonicalGoalInEnvironment, coinductive_goal: bool) -> Table<C> {
         Table {
             table_goal,
             coinductive_goal,
@@ -58,23 +58,23 @@ impl<C: Context> Table<C> {
         }
     }
 
-    crate fn push_strand(&mut self, strand: CanonicalStrand<C>) {
+    pub(crate) fn push_strand(&mut self, strand: CanonicalStrand<C>) {
         self.strands.push_back(strand);
     }
 
-    crate fn extend_strands(&mut self, strands: impl IntoIterator<Item = CanonicalStrand<C>>) {
+    pub(crate) fn extend_strands(&mut self, strands: impl IntoIterator<Item = CanonicalStrand<C>>) {
         self.strands.extend(strands);
     }
 
-    crate fn strands_mut(&mut self) -> impl Iterator<Item = &mut CanonicalStrand<C>> {
+    pub(crate) fn strands_mut(&mut self) -> impl Iterator<Item = &mut CanonicalStrand<C>> {
         self.strands.iter_mut()
     }
 
-    crate fn take_strands(&mut self) -> VecDeque<CanonicalStrand<C>> {
+    pub(crate) fn take_strands(&mut self) -> VecDeque<CanonicalStrand<C>> {
         mem::replace(&mut self.strands, VecDeque::new())
     }
 
-    crate fn pop_next_strand(&mut self) -> Option<CanonicalStrand<C>> {
+    pub(crate) fn pop_next_strand(&mut self) -> Option<CanonicalStrand<C>> {
         self.strands.pop_front()
     }
 
@@ -127,7 +127,7 @@ impl<C: Context> Table<C> {
 }
 
 impl AnswerIndex {
-    crate const ZERO: AnswerIndex = AnswerIndex { value: 0 };
+    pub(crate) const ZERO: AnswerIndex = AnswerIndex { value: 0 };
 }
 
 impl<C: Context> Answer<C> {

chalk-engine/src/tables.rs

@@ -1,11 +1,11 @@
-use crate::TableIndex;
-use crate::context::prelude::*;
-use crate::table::Table;
+use TableIndex;
+use context::prelude::*;
+use table::Table;
 use rustc_hash::FxHashMap;
 use std::ops::{Index, IndexMut};
 
 /// See `Forest`.
-crate struct Tables<C: Context> {
+pub(crate) struct Tables<C: Context> {
     /// Maps from a canonical goal to the index of its table.
     table_indices: FxHashMap<C::UCanonicalGoalInEnvironment, TableIndex>,
 
@@ -15,7 +15,7 @@ crate struct Tables<C: Context> {
 }
 
 impl<C: Context> Tables<C> {
-    crate fn new() -> Tables<C> {
+    pub(crate) fn new() -> Tables<C> {
         Tables {
             table_indices: FxHashMap::default(),
             tables: Vec::default(),