Merge pull request #173 from nikomatsakis/type-alias-bounds

type alias bounds and other miscellany

Author: nikomatsakis

Cargo.lock

@@ -15,7 +15,7 @@ ena = "0.4"
 error-chain = "0.12.0"
 itertools = "0.7.8"
 lalrpop-intern = "0.14"
-petgraph = "0.4.5"
+petgraph = "0.4.13"
 rustyline = "1.0"
 serde = "1.0"
 serde_derive = "1.0"
@@ -30,7 +30,7 @@ version = "0.1.0"
 path = "chalk-macros"
 
 [dependencies.chalk-engine]
-version = "0.7.0"
+version = "0.7.1"
 path = "chalk-engine"
 
 [workspace]

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "chalk-engine"
-version = "0.7.0"
+version = "0.7.1"
 description = "Core trait engine from Chalk project"
 license = "Apache-2.0/MIT"
 authors = ["Rust Compiler Team", "Chalk developers"]

chalk-engine/Cargo.toml

@@ -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.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/context/prelude.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/forest.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/hh.rs

@@ -49,13 +49,9 @@
 //! - 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(macro_vis_matcher)]
 #![feature(step_trait)]
 #![feature(non_modrs_mods)]
-#![feature(rustc_private)]
 
 #[macro_use]
 extern crate chalk_macros;
@@ -65,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/lib.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;
@@ -56,7 +56,8 @@ enum RecursiveSearchFail {
     QuantumExceeded,
 }
 
-type StrandResult<C, T> = Result<T, StrandFail<C>>;
+#[allow(type_alias_bounds)]
+type StrandResult<C: Context, T> = Result<T, StrandFail<C>>;
 
 /// Possible failures from pursuing a particular strand.
 #[derive(Debug)]
@@ -183,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()
     }
 
@@ -691,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 {
@@ -1166,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/logic.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/simplify.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/stack.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> {