Merge branch 'master' into GAT-step3

tmandry · web-flow · commit 40618966be46 · 2018-05-24T14:56:36.000-05:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -30,7 +30,7 @@ version = "0.1.0"
 path = "chalk-macros"
 
 [dependencies.chalk-engine]
-version = "0.5.0"
+version = "0.6.0"
 path = "chalk-engine"
 
 [workspace]
diff --git a/chalk-engine/Cargo.toml b/chalk-engine/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "chalk-engine"
-version = "0.5.0"
+version = "0.6.0"
 description = "Core trait engine from Chalk project"
 license = "Apache-2.0/MIT"
 authors = ["Rust Compiler Team", "Chalk developers"]
@@ -9,13 +9,12 @@ readme = "README.md"
 keywords = ["compiler", "traits", "prolog"]
 
 [features]
-default = ["stack_protection", "stabler"]
+default = ["stack_protection"]
 stack_protection = ["stacker"]
-stabler = ["fxhash"]
 
 [dependencies]
 stacker = { version = "0.1.2", optional = true }
-fxhash = { version = "0.2.1", optional = true }
+rustc-hash = { version = "1.0.0" }
 
 [dependencies.chalk-macros]
 version = "0.1.0"
diff --git a/chalk-engine/src/hashmap.rs b/chalk-engine/src/hashmap.rs
diff --git a/chalk-engine/src/lib.rs b/chalk-engine/src/lib.rs
@@ -56,35 +56,30 @@
 #![feature(step_trait)]
 #![feature(non_modrs_mods)]
 #![feature(rustc_private)]
-
 //FIXME(2018-05-14): In rustc we build using beta and dyn trait is still unstable right now, so we
 // need to allow this to remove the warning about dyn_trait being stable in the latest rust.
 // We should probably eventually remove this `allow` and delete any unecessary `feature` declarations.
 #![allow(stable_features)]
 #![feature(dyn_trait)]
 
-#[macro_use] extern crate chalk_macros;
+#[macro_use]
+extern crate chalk_macros;
 
 #[cfg(feature = "stack_protection")]
 extern crate stacker;
 
-#[cfg(feature = "stabler")]
-extern crate fxhash;
-
-#[cfg(not(feature = "stabler"))]
-extern crate rustc_data_structures;
+extern crate rustc_hash;
 
 use crate::context::Context;
-use crate::hashmap::FxHashSet;
+use rustc_hash::FxHashSet;
 use std::cmp::min;
 use std::usize;
 
 pub mod context;
+mod derived;
 pub mod fallible;
 pub mod forest;
-pub mod hashmap;
 pub mod hh;
-mod derived;
 mod logic;
 mod simplify;
 mod stack;
diff --git a/chalk-engine/src/logic.rs b/chalk-engine/src/logic.rs
@@ -7,7 +7,7 @@ use crate::hh::HhGoal;
 use crate::stack::StackIndex;
 use crate::strand::{CanonicalStrand, SelectedSubgoal, Strand};
 use crate::table::{Answer, AnswerIndex};
-use crate::hashmap::FxHashSet;
+use rustc_hash::FxHashSet;
 use std::marker::PhantomData;
 use std::mem;
 
diff --git a/chalk-engine/src/table.rs b/chalk-engine/src/table.rs
@@ -1,7 +1,7 @@
 use crate::{DelayedLiteralSet, DelayedLiteralSets};
 use crate::context::prelude::*;
 use crate::strand::CanonicalStrand;
-use crate::hashmap::FxHashMap;
+use rustc_hash::FxHashMap;
 use std::collections::VecDeque;
 use std::collections::hash_map::Entry;
 use std::mem;
diff --git a/chalk-engine/src/tables.rs b/chalk-engine/src/tables.rs
@@ -1,7 +1,7 @@
 use crate::TableIndex;
 use crate::context::prelude::*;
 use crate::table::Table;
-use crate::hashmap::FxHashMap;
+use rustc_hash::FxHashMap;
 use std::ops::{Index, IndexMut};
 
 /// See `Forest`.
diff --git a/chalk-parse/src/ast.rs b/chalk-parse/src/ast.rs
@@ -34,6 +34,7 @@ pub struct StructDefn {
 
 pub struct StructFlags {
     pub external: bool,
+    pub fundamental: bool,
 }
 
 pub struct TraitDefn {
diff --git a/chalk-parse/src/parser.lalrpop b/chalk-parse/src/parser.lalrpop
@@ -39,9 +39,10 @@ ExternalKeyword: () = "extern";
 AutoKeyword: () = "#" "[" "auto" "]";
 MarkerKeyword: () = "#" "[" "marker" "]";
 DerefLangItem: () = "#" "[" "lang_deref" "]";
+FundamentalKeyword: () = "#" "[" "fundamental" "]";
 
 StructDefn: StructDefn = {
-    <external:ExternalKeyword?> "struct" <n:Id><p:Angle<ParameterKind>>
+    <fundamental:FundamentalKeyword?> <external:ExternalKeyword?> "struct" <n:Id><p:Angle<ParameterKind>>
         <w:QuantifiedWhereClauses> "{" <f:Fields> "}" => StructDefn
     {
         name: n,
@@ -50,6 +51,7 @@ StructDefn: StructDefn = {
         fields: f,
         flags: StructFlags {
             external: external.is_some(),
+            fundamental: fundamental.is_some(),
         },
     }
 };
diff --git a/libstd.chalk b/libstd.chalk
@@ -24,6 +24,7 @@ struct Rc<T> { }
 impl<T> Clone for Rc<T> { }
 impl<T> Sized for Rc<T> { }
 
+#[fundamental]
 struct Box<T> { }
 impl<T> AsRef<T> for Box<T> where T: Sized { }
 impl<T> Clone for Box<T> where T: Clone { }
@@ -39,4 +40,3 @@ impl<T> AsRef<Slice<T>> for Vec<T> where T: Sized { }
 impl<T> AsRef<Vec<T>> for Vec<T> where T: Sized { }
 impl<T> Clone for Vec<T> where T: Clone, T: Sized { }
 impl<T> Sized for Vec<T> where T: Sized { }
-
diff --git a/src/ir.rs b/src/ir.rs
@@ -237,6 +237,7 @@ pub struct StructDatumBound {
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct StructFlags {
     crate external: bool,
+    crate fundamental: bool,
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
@@ -443,6 +444,17 @@ pub struct ApplicationTy {
     crate parameters: Vec<Parameter>,
 }
 
+impl ApplicationTy {
+    crate fn first_type_parameter(&self) -> Option<Ty> {
+        // This unwrap() is safe because is_ty ensures that we definitely have a Ty
+        self.parameters.iter().find(|p| p.is_ty()).map(|p| p.clone().ty().unwrap())
+    }
+
+    crate fn len_type_parameters(&self) -> usize {
+        self.parameters.iter().filter(|p| p.is_ty()).count()
+    }
+}
+
 #[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub enum ParameterKind<T, L = T> {
     Ty(T),
@@ -484,6 +496,13 @@ impl<T, L> ParameterKind<T, L> {
         }
     }
 
+    crate fn is_ty(&self) -> bool {
+        match self {
+            ParameterKind::Ty(_) => true,
+            ParameterKind::Lifetime(_) => false,
+        }
+    }
+
     crate fn ty(self) -> Option<T> {
         match self {
             ParameterKind::Ty(t) => Some(t),
diff --git a/src/ir/lowering.rs b/src/ir/lowering.rs
@@ -572,6 +572,10 @@ impl LowerStructDefn for StructDefn {
                     .collect(),
             };
 
+            if self.flags.fundamental && self_ty.len_type_parameters() != 1 {
+                bail!("Only fundamental types with a single parameter are supported");
+            }
+
             let fields: Result<_> = self.fields.iter().map(|f| f.ty.lower(env)).collect();
             let where_clauses = self.lower_where_clauses(env)?;
 
@@ -581,6 +585,7 @@ impl LowerStructDefn for StructDefn {
                 where_clauses,
                 flags: ir::StructFlags {
                     external: self.flags.external,
+                    fundamental: self.flags.fundamental,
                 },
             })
         })?;
diff --git a/src/ir/lowering/test.rs b/src/ir/lowering/test.rs
@@ -406,3 +406,16 @@ fn deref_trait() {
         }
     }
 }
+
+fn fundamental_multiple_type_parameters() {
+    lowering_error! {
+        program {
+            #[fundamental]
+            struct Boxes<T, U> { }
+        }
+
+        error_msg {
+            "Only fundamental types with a single parameter are supported"
+        }
+    }
+}
diff --git a/src/rules.rs b/src/rules.rs
@@ -295,6 +295,15 @@ impl ir::StructDatum {
         // If the type Foo is not marked `extern`, we also generate:
         //
         //    forall<T> { IsLocalTy(Foo<T>) }
+        //
+        // Given an `extern` type that is also fundamental:
+        //
+        //    #[fundamental]
+        //    extern struct Box<T> {}
+        //
+        // We generate the following clause:
+        //
+        //    forall<T> { IsLocalTy(Box<T>) :- IsLocalTy(T) }
 
         let wf = self.binders.map_ref(|bound_datum| {
             ir::ProgramClauseImplication {
@@ -321,6 +330,30 @@ impl ir::StructDatum {
             }).cast();
 
             clauses.push(is_local);
+        } else if self.binders.value.flags.fundamental {
+            // If a type is `extern`, but is also `#[fundamental]`, it satisfies IsLocalTy
+            // if and only if its parameters satisfy IsLocalTy
+
+            // Fundamental types must always have at least one type parameter for this rule to
+            // make any sense. We currently do not have have any fundamental types with more than
+            // one type parameter, nor do we know what the behaviour for that should be. Thus, we
+            // are asserting here that there is only a single type parameter until the day when
+            // someone makes a decision about how that should behave.
+            assert_eq!(self.binders.value.self_ty.len_type_parameters(), 1,
+                "Only fundamental types with a single parameter are supported");
+
+            let local_fundamental = self.binders.map_ref(|bound_datum| ir::ProgramClauseImplication {
+                consequence: ir::DomainGoal::IsLocalTy(bound_datum.self_ty.clone().cast()),
+                conditions: vec![
+                    ir::DomainGoal::IsLocalTy(
+                        // This unwrap is safe because we asserted above for the presence of a type
+                        // parameter
+                        bound_datum.self_ty.first_type_parameter().unwrap()
+                    ).cast(),
+                ],
+            }).cast();
+
+            clauses.push(local_fundamental);
         }
 
         let condition = ir::DomainGoal::FromEnvTy(self.binders.value.self_ty.clone().cast());
diff --git a/src/solve/test.rs b/src/solve/test.rs

Original file line number	Diff line number	Diff line change
`@@ -34,6 +34,7 @@ pub struct StructDefn {`
`34`	`34`
`35`	`35`	`pub struct StructFlags {`
`36`	`36`	`pub external: bool,`
	`37`	`+ pub fundamental: bool,`
`37`	`38`	`}`
`38`	`39`
`39`	`40`	`pub struct TraitDefn {`