fix record labels in the face of bound variables

Author: Markus Westerlind

libflux/flux-core/src/semantic/bootstrap.rs

@@ -317,7 +317,9 @@ fn add_record_to_map(
             env.insert(
                 match &head.k {
                     RecordLabel::Concrete(s) => s.clone().into(),
-                    RecordLabel::Variable(_) => bail!("Record contains variable labels"),
+                    RecordLabel::BoundVariable(_) | RecordLabel::Variable(_) => {
+                        bail!("Record contains variable labels")
+                    }
                 },
                 PolyType {
                     vars: new_vars,

libflux/flux-core/src/semantic/convert.rs

@@ -574,7 +574,7 @@ impl<'a> Converter<'a> {
                                 .entry(prop.name.name.clone())
                                 .or_insert_with(|| self.sub.fresh())
                                 .clone();
-                            tvar.into()
+                            types::RecordLabel::BoundVariable(tvar)
                         } else {
                             types::Label::from(self.symbols.lookup(&prop.name.name)).into()
                         },

libflux/flux-core/src/semantic/nodes.rs

@@ -1846,7 +1846,7 @@ impl IdentifierExpr {
     fn infer(&mut self, infer: &mut InferState<'_, '_>) -> Result {
         let poly = infer.lookup(&self.loc, &self.name);
 
-        let (t, cons) = infer::instantiate(poly, infer.sub, self.loc.clone());
+        let (t, cons) = infer::instantiate(poly.clone(), infer.sub, self.loc.clone());
         infer.solve(&cons);
         self.typ = t;
         Ok(())

libflux/flux-core/src/semantic/types.rs

@@ -1245,7 +1245,7 @@ impl Record {
         let has_variable_label = |r: &Record| {
             r.fields().any(|prop| match prop.k {
                 RecordLabel::Variable(v) => unifier.sub.try_apply(v).is_none(),
-                RecordLabel::Concrete(_) => false,
+                RecordLabel::BoundVariable(_) | RecordLabel::Concrete(_) => false,
             })
         };
         if has_variable_label(self) || has_variable_label(actual) {
@@ -1339,7 +1339,9 @@ impl Record {
                     },
                     tail: MonoType::Var(var),
                 });
+                log::error!("{} = {}", l, act);
                 l.unify(&act, unifier);
+                log::error!("{} = {}", exp, r);
                 exp.unify(r, unifier);
             }
             // If we are expecting {a: u | r} but find {}, label `a` is missing.
@@ -1450,22 +1452,39 @@ fn unify_in_context<T>(
 }
 
 /// Labels in records that are allowed be variables
-#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Serialize, derive_more::From)]
+#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Serialize)]
 pub enum RecordLabel {
     /// A variable label
     Variable(Tvar),
+    /// A variable label
+    BoundVariable(Tvar),
     /// A concrete label
     Concrete(Label),
 }
 
+impl From<Label> for RecordLabel {
+    fn from(label: Label) -> Self {
+        Self::Concrete(label)
+    }
+}
+
 impl Substitutable for RecordLabel {
     fn walk(&self, sub: &dyn Substituter) -> Option<Self> {
         match self {
             Self::Variable(tvr) => sub.try_apply(*tvr).and_then(|new| match new {
                 MonoType::Label(l) => Some(Self::Concrete(l)),
+                MonoType::BoundVar(l) => Some(Self::BoundVariable(l)),
                 MonoType::Var(l) => Some(Self::Variable(l)),
                 _ => None,
             }),
+
+            Self::BoundVariable(tvr) => sub.try_apply_bound(*tvr).and_then(|new| match new {
+                MonoType::Label(l) => Some(Self::Concrete(l)),
+                MonoType::BoundVar(l) => Some(Self::BoundVariable(l)),
+                MonoType::Var(l) => Some(Self::Variable(l)),
+                _ => None,
+            }),
+
             Self::Concrete(_) => None,
         }
     }
@@ -1474,7 +1493,8 @@ impl Substitutable for RecordLabel {
 impl fmt::Display for RecordLabel {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            Self::Variable(v) => v.fmt(f),
+            Self::BoundVariable(v) => v.fmt(f),
+            Self::Variable(v) => write!(f, "#{}", v),
             Self::Concrete(v) => v.fmt(f),
         }
     }
@@ -1483,7 +1503,7 @@ impl fmt::Display for RecordLabel {
 impl PartialEq<str> for RecordLabel {
     fn eq(&self, other: &str) -> bool {
         match self {
-            Self::Variable(_) => false,
+            Self::BoundVariable(_) | Self::Variable(_) => false,
             Self::Concrete(l) => l == other,
         }
     }
@@ -1630,10 +1650,8 @@ where
     V: Substitutable + Clone,
 {
     fn walk(&self, sub: &dyn Substituter) -> Option<Self> {
-        self.v.visit(sub).map(|v| Property {
-            k: self.k.clone(),
-            v,
-        })
+        let Self { k, v } = self;
+        apply2(k, v, sub).map(|(k, v)| Property { k, v })
     }
 }