diff --git a/src/bindgen/ir/constant.rs b/src/bindgen/ir/constant.rs
index f04260fdf..cca937f7f 100644
--- a/src/bindgen/ir/constant.rs
+++ b/src/bindgen/ir/constant.rs
@@ -20,10 +20,20 @@ use crate::bindgen::library::Library;
 use crate::bindgen::writer::{Source, SourceWriter};
 use crate::bindgen::Bindings;
 
+fn member_to_ident(member: &syn::Member) -> String {
+    match member {
+        syn::Member::Named(ref name) => name.unraw().to_string(),
+        syn::Member::Unnamed(ref index) => format!("_{}", index.index),
+    }
+}
+
 #[derive(Debug, Clone)]
 pub enum Literal {
     Expr(String),
-    Path(String),
+    Path {
+        associated_to: Option<(Path, String)>,
+        name: String,
+    },
     PostfixUnaryOp {
         op: &'static str,
         value: Box<Literal>,
@@ -33,6 +43,10 @@ pub enum Literal {
         op: &'static str,
         right: Box<Literal>,
     },
+    FieldAccess {
+        base: Box<Literal>,
+        field: String,
+    },
     Struct {
         path: Path,
         export_name: String,
@@ -58,6 +72,9 @@ impl Literal {
                 left.replace_self_with(self_ty);
                 right.replace_self_with(self_ty);
             }
+            Literal::FieldAccess { ref mut base, .. } => {
+                base.replace_self_with(self_ty);
+            }
             Literal::Struct {
                 ref mut path,
                 ref mut export_name,
@@ -77,20 +94,38 @@ impl Literal {
                 ty.replace_self_with(self_ty);
                 value.replace_self_with(self_ty);
             }
-            Literal::Expr(..) | Literal::Path(..) => {}
+            Literal::Path {
+                ref mut associated_to,
+                ..
+            } => {
+                if let Some((ref mut path, ref mut export_name)) = *associated_to {
+                    if path.replace_self_with(self_ty) {
+                        *export_name = self_ty.name().to_owned();
+                    }
+                }
+            }
+            Literal::Expr(..) => {}
         }
     }
 
     fn is_valid(&self, bindings: &Bindings) -> bool {
         match *self {
             Literal::Expr(..) => true,
-            Literal::Path(..) => true,
+            Literal::Path {
+                ref associated_to, ..
+            } => {
+                if let Some((ref path, _export_name)) = associated_to {
+                    return bindings.struct_exists(path);
+                }
+                true
+            }
             Literal::PostfixUnaryOp { ref value, .. } => value.is_valid(bindings),
             Literal::BinOp {
                 ref left,
                 ref right,
                 ..
             } => left.is_valid(bindings) && right.is_valid(bindings),
+            Literal::FieldAccess { ref base, .. } => base.is_valid(bindings),
             Literal::Struct { ref path, .. } => bindings.struct_exists(path),
             Literal::Cast { ref value, .. } => value.is_valid(bindings),
         }
@@ -98,14 +133,14 @@ impl Literal {
 
     pub fn uses_only_primitive_types(&self) -> bool {
         match self {
-            Literal::Expr(..) => true,
-            Literal::Path(..) => true,
+            Literal::Expr(..) | Literal::Path { .. } => true,
             Literal::PostfixUnaryOp { ref value, .. } => value.uses_only_primitive_types(),
             Literal::BinOp {
                 ref left,
                 ref right,
                 ..
             } => left.uses_only_primitive_types() & right.uses_only_primitive_types(),
+            Literal::FieldAccess { ref base, .. } => base.uses_only_primitive_types(),
             Literal::Struct { .. } => false,
             Literal::Cast { ref value, ref ty } => {
                 value.uses_only_primitive_types() && ty.is_primitive_or_ptr_primitive()
@@ -127,8 +162,18 @@ impl Literal {
                     lit.rename_for_config(config);
                 }
             }
-            Literal::Path(ref mut name) => {
-                config.export.rename(name);
+            Literal::FieldAccess { ref mut base, .. } => {
+                base.rename_for_config(config);
+            }
+            Literal::Path {
+                ref mut associated_to,
+                ref mut name,
+            } => {
+                if let Some((_path, ref mut export_name)) = associated_to {
+                    config.export.rename(export_name);
+                } else {
+                    config.export.rename(name);
+                }
             }
             Literal::PostfixUnaryOp { ref mut value, .. } => {
                 value.rename_for_config(config);
@@ -220,6 +265,15 @@ impl Literal {
                 }
             }
 
+            syn::Expr::Field(syn::ExprField {
+                ref base,
+                ref member,
+                ..
+            }) => Ok(Literal::FieldAccess {
+                base: Box::new(Literal::load(base)?),
+                field: member_to_ident(member),
+            }),
+
             syn::Expr::Struct(syn::ExprStruct {
                 ref path,
                 ref fields,
@@ -228,10 +282,7 @@ impl Literal {
                 let struct_name = path.segments[0].ident.unraw().to_string();
                 let mut field_map = HashMap::<String, Literal>::default();
                 for field in fields {
-                    let ident = match field.member {
-                        syn::Member::Named(ref name) => name.unraw().to_string(),
-                        syn::Member::Unnamed(ref index) => format!("_{}", index.index),
-                    };
+                    let ident = member_to_ident(&field.member);
                     let key = ident.to_string();
                     let value = Literal::load(&field.expr)?;
                     field_map.insert(key, value);
@@ -257,16 +308,23 @@ impl Literal {
             },
 
             // Match identifiers, like `5 << SHIFT`
-            syn::Expr::Path(syn::ExprPath {
-                path: syn::Path { ref segments, .. },
-                ..
-            }) => {
-                // Handle only the simplest identifiers and error for anything else.
-                if segments.len() == 1 {
-                    Ok(Literal::Path(format!("{}", segments.last().unwrap().ident)))
-                } else {
-                    Err(format!("Unsupported path expression. {:?}", *segments))
-                }
+            syn::Expr::Path(syn::ExprPath { ref path, .. }) => {
+                // Handle only the simplest identifiers and Associated::IDENT
+                // kind of syntax.
+                Ok(match path.segments.len() {
+                    1 => Literal::Path {
+                        associated_to: None,
+                        name: path.segments[0].ident.to_string(),
+                    },
+                    2 => {
+                        let struct_name = path.segments[0].ident.to_string();
+                        Literal::Path {
+                            associated_to: Some((Path::new(&struct_name), struct_name)),
+                            name: path.segments[1].ident.to_string(),
+                        }
+                    }
+                    _ => return Err(format!("Unsupported path expression. {:?}", path)),
+                })
             }
 
             syn::Expr::Paren(syn::ExprParen { ref expr, .. }) => Self::load(expr),
@@ -295,7 +353,33 @@ impl Literal {
                 ("false", Language::Cython) => write!(out, "False"),
                 (v, _) => write!(out, "{}", v),
             },
-            Literal::Path(v) => write!(out, "{}", v),
+            Literal::Path {
+                ref associated_to,
+                ref name,
+            } => {
+                if let Some((_, ref export_name)) = associated_to {
+                    let path_separator = match config.language {
+                        Language::Cython | Language::C => "_",
+                        Language::Cxx => {
+                            if config.structure.associated_constants_in_body {
+                                "::"
+                            } else {
+                                "_"
+                            }
+                        }
+                    };
+                    write!(out, "{}{}", export_name, path_separator)
+                }
+                write!(out, "{}", name)
+            }
+            Literal::FieldAccess {
+                ref base,
+                ref field,
+            } => {
+                write!(out, "(");
+                base.write(config, out);
+                write!(out, ").{}", field);
+            }
             Literal::PostfixUnaryOp { op, ref value } => {
                 write!(out, "{}", op);
                 value.write(config, out);
diff --git a/tests/expectations/associated_in_body.both.c b/tests/expectations/associated_in_body.both.c
index 16035b18e..977ab8bce 100644
--- a/tests/expectations/associated_in_body.both.c
+++ b/tests/expectations/associated_in_body.both.c
@@ -27,9 +27,12 @@ typedef struct StyleAlignFlags {
  * 'end'
  */
 #define StyleAlignFlags_END (StyleAlignFlags){ .bits = (uint8_t)(1 << 2) }
+#define StyleAlignFlags_ALIAS (StyleAlignFlags){ .bits = (uint8_t)(StyleAlignFlags_END).bits }
 /**
  * 'flex-start'
  */
 #define StyleAlignFlags_FLEX_START (StyleAlignFlags){ .bits = (uint8_t)(1 << 3) }
+#define StyleAlignFlags_MIXED (StyleAlignFlags){ .bits = (uint8_t)(((1 << 4) | (StyleAlignFlags_FLEX_START).bits) | (StyleAlignFlags_END).bits) }
+#define StyleAlignFlags_MIXED_SELF (StyleAlignFlags){ .bits = (uint8_t)(((1 << 5) | (StyleAlignFlags_FLEX_START).bits) | (StyleAlignFlags_END).bits) }
 
 void root(struct StyleAlignFlags flags);
diff --git a/tests/expectations/associated_in_body.both.compat.c b/tests/expectations/associated_in_body.both.compat.c
index ad4e84172..910c9797c 100644
--- a/tests/expectations/associated_in_body.both.compat.c
+++ b/tests/expectations/associated_in_body.both.compat.c
@@ -27,10 +27,13 @@ typedef struct StyleAlignFlags {
  * 'end'
  */
 #define StyleAlignFlags_END (StyleAlignFlags){ .bits = (uint8_t)(1 << 2) }
+#define StyleAlignFlags_ALIAS (StyleAlignFlags){ .bits = (uint8_t)(StyleAlignFlags_END).bits }
 /**
  * 'flex-start'
  */
 #define StyleAlignFlags_FLEX_START (StyleAlignFlags){ .bits = (uint8_t)(1 << 3) }
+#define StyleAlignFlags_MIXED (StyleAlignFlags){ .bits = (uint8_t)(((1 << 4) | (StyleAlignFlags_FLEX_START).bits) | (StyleAlignFlags_END).bits) }
+#define StyleAlignFlags_MIXED_SELF (StyleAlignFlags){ .bits = (uint8_t)(((1 << 5) | (StyleAlignFlags_FLEX_START).bits) | (StyleAlignFlags_END).bits) }
 
 #ifdef __cplusplus
 extern "C" {
diff --git a/tests/expectations/associated_in_body.c b/tests/expectations/associated_in_body.c
index 20cf7aff8..a0192dfc6 100644
--- a/tests/expectations/associated_in_body.c
+++ b/tests/expectations/associated_in_body.c
@@ -27,9 +27,12 @@ typedef struct {
  * 'end'
  */
 #define StyleAlignFlags_END (StyleAlignFlags){ .bits = (uint8_t)(1 << 2) }
+#define StyleAlignFlags_ALIAS (StyleAlignFlags){ .bits = (uint8_t)(StyleAlignFlags_END).bits }
 /**
  * 'flex-start'
  */
 #define StyleAlignFlags_FLEX_START (StyleAlignFlags){ .bits = (uint8_t)(1 << 3) }
+#define StyleAlignFlags_MIXED (StyleAlignFlags){ .bits = (uint8_t)(((1 << 4) | (StyleAlignFlags_FLEX_START).bits) | (StyleAlignFlags_END).bits) }
+#define StyleAlignFlags_MIXED_SELF (StyleAlignFlags){ .bits = (uint8_t)(((1 << 5) | (StyleAlignFlags_FLEX_START).bits) | (StyleAlignFlags_END).bits) }
 
 void root(StyleAlignFlags flags);
diff --git a/tests/expectations/associated_in_body.compat.c b/tests/expectations/associated_in_body.compat.c
index 2872416b0..a7c3e4b27 100644
--- a/tests/expectations/associated_in_body.compat.c
+++ b/tests/expectations/associated_in_body.compat.c
@@ -27,10 +27,13 @@ typedef struct {
  * 'end'
  */
 #define StyleAlignFlags_END (StyleAlignFlags){ .bits = (uint8_t)(1 << 2) }
+#define StyleAlignFlags_ALIAS (StyleAlignFlags){ .bits = (uint8_t)(StyleAlignFlags_END).bits }
 /**
  * 'flex-start'
  */
 #define StyleAlignFlags_FLEX_START (StyleAlignFlags){ .bits = (uint8_t)(1 << 3) }
+#define StyleAlignFlags_MIXED (StyleAlignFlags){ .bits = (uint8_t)(((1 << 4) | (StyleAlignFlags_FLEX_START).bits) | (StyleAlignFlags_END).bits) }
+#define StyleAlignFlags_MIXED_SELF (StyleAlignFlags){ .bits = (uint8_t)(((1 << 5) | (StyleAlignFlags_FLEX_START).bits) | (StyleAlignFlags_END).bits) }
 
 #ifdef __cplusplus
 extern "C" {
diff --git a/tests/expectations/associated_in_body.cpp b/tests/expectations/associated_in_body.cpp
index 9bbf210a9..8db4148a0 100644
--- a/tests/expectations/associated_in_body.cpp
+++ b/tests/expectations/associated_in_body.cpp
@@ -41,7 +41,10 @@ struct StyleAlignFlags {
   static const StyleAlignFlags NORMAL;
   static const StyleAlignFlags START;
   static const StyleAlignFlags END;
+  static const StyleAlignFlags ALIAS;
   static const StyleAlignFlags FLEX_START;
+  static const StyleAlignFlags MIXED;
+  static const StyleAlignFlags MIXED_SELF;
 };
 /// 'auto'
 inline const StyleAlignFlags StyleAlignFlags::AUTO = StyleAlignFlags{ /* .bits = */ (uint8_t)0 };
@@ -51,8 +54,11 @@ inline const StyleAlignFlags StyleAlignFlags::NORMAL = StyleAlignFlags{ /* .bits
 inline const StyleAlignFlags StyleAlignFlags::START = StyleAlignFlags{ /* .bits = */ (uint8_t)(1 << 1) };
 /// 'end'
 inline const StyleAlignFlags StyleAlignFlags::END = StyleAlignFlags{ /* .bits = */ (uint8_t)(1 << 2) };
+inline const StyleAlignFlags StyleAlignFlags::ALIAS = StyleAlignFlags{ /* .bits = */ (uint8_t)(StyleAlignFlags::END).bits };
 /// 'flex-start'
 inline const StyleAlignFlags StyleAlignFlags::FLEX_START = StyleAlignFlags{ /* .bits = */ (uint8_t)(1 << 3) };
+inline const StyleAlignFlags StyleAlignFlags::MIXED = StyleAlignFlags{ /* .bits = */ (uint8_t)(((1 << 4) | (StyleAlignFlags::FLEX_START).bits) | (StyleAlignFlags::END).bits) };
+inline const StyleAlignFlags StyleAlignFlags::MIXED_SELF = StyleAlignFlags{ /* .bits = */ (uint8_t)(((1 << 5) | (StyleAlignFlags::FLEX_START).bits) | (StyleAlignFlags::END).bits) };
 
 extern "C" {
 
diff --git a/tests/expectations/associated_in_body.pyx b/tests/expectations/associated_in_body.pyx
index 4444c8c56..54f69e3b7 100644
--- a/tests/expectations/associated_in_body.pyx
+++ b/tests/expectations/associated_in_body.pyx
@@ -19,7 +19,10 @@ cdef extern from *:
   const StyleAlignFlags StyleAlignFlags_START # = <StyleAlignFlags>{ <uint8_t>(1 << 1) }
   # 'end'
   const StyleAlignFlags StyleAlignFlags_END # = <StyleAlignFlags>{ <uint8_t>(1 << 2) }
+  const StyleAlignFlags StyleAlignFlags_ALIAS # = <StyleAlignFlags>{ <uint8_t>(StyleAlignFlags_END).bits }
   # 'flex-start'
   const StyleAlignFlags StyleAlignFlags_FLEX_START # = <StyleAlignFlags>{ <uint8_t>(1 << 3) }
+  const StyleAlignFlags StyleAlignFlags_MIXED # = <StyleAlignFlags>{ <uint8_t>(((1 << 4) | (StyleAlignFlags_FLEX_START).bits) | (StyleAlignFlags_END).bits) }
+  const StyleAlignFlags StyleAlignFlags_MIXED_SELF # = <StyleAlignFlags>{ <uint8_t>(((1 << 5) | (StyleAlignFlags_FLEX_START).bits) | (StyleAlignFlags_END).bits) }
 
   void root(StyleAlignFlags flags);
diff --git a/tests/expectations/associated_in_body.tag.c b/tests/expectations/associated_in_body.tag.c
index 2ac532278..a55c1f83f 100644
--- a/tests/expectations/associated_in_body.tag.c
+++ b/tests/expectations/associated_in_body.tag.c
@@ -27,9 +27,12 @@ struct StyleAlignFlags {
  * 'end'
  */
 #define StyleAlignFlags_END (StyleAlignFlags){ .bits = (uint8_t)(1 << 2) }
+#define StyleAlignFlags_ALIAS (StyleAlignFlags){ .bits = (uint8_t)(StyleAlignFlags_END).bits }
 /**
  * 'flex-start'
  */
 #define StyleAlignFlags_FLEX_START (StyleAlignFlags){ .bits = (uint8_t)(1 << 3) }
+#define StyleAlignFlags_MIXED (StyleAlignFlags){ .bits = (uint8_t)(((1 << 4) | (StyleAlignFlags_FLEX_START).bits) | (StyleAlignFlags_END).bits) }
+#define StyleAlignFlags_MIXED_SELF (StyleAlignFlags){ .bits = (uint8_t)(((1 << 5) | (StyleAlignFlags_FLEX_START).bits) | (StyleAlignFlags_END).bits) }
 
 void root(struct StyleAlignFlags flags);
diff --git a/tests/expectations/associated_in_body.tag.compat.c b/tests/expectations/associated_in_body.tag.compat.c
index 056632f50..5ce56b79c 100644
--- a/tests/expectations/associated_in_body.tag.compat.c
+++ b/tests/expectations/associated_in_body.tag.compat.c
@@ -27,10 +27,13 @@ struct StyleAlignFlags {
  * 'end'
  */
 #define StyleAlignFlags_END (StyleAlignFlags){ .bits = (uint8_t)(1 << 2) }
+#define StyleAlignFlags_ALIAS (StyleAlignFlags){ .bits = (uint8_t)(StyleAlignFlags_END).bits }
 /**
  * 'flex-start'
  */
 #define StyleAlignFlags_FLEX_START (StyleAlignFlags){ .bits = (uint8_t)(1 << 3) }
+#define StyleAlignFlags_MIXED (StyleAlignFlags){ .bits = (uint8_t)(((1 << 4) | (StyleAlignFlags_FLEX_START).bits) | (StyleAlignFlags_END).bits) }
+#define StyleAlignFlags_MIXED_SELF (StyleAlignFlags){ .bits = (uint8_t)(((1 << 5) | (StyleAlignFlags_FLEX_START).bits) | (StyleAlignFlags_END).bits) }
 
 #ifdef __cplusplus
 extern "C" {
diff --git a/tests/expectations/associated_in_body.tag.pyx b/tests/expectations/associated_in_body.tag.pyx
index c02e58fca..a489a2871 100644
--- a/tests/expectations/associated_in_body.tag.pyx
+++ b/tests/expectations/associated_in_body.tag.pyx
@@ -19,7 +19,10 @@ cdef extern from *:
   const StyleAlignFlags StyleAlignFlags_START # = <StyleAlignFlags>{ <uint8_t>(1 << 1) }
   # 'end'
   const StyleAlignFlags StyleAlignFlags_END # = <StyleAlignFlags>{ <uint8_t>(1 << 2) }
+  const StyleAlignFlags StyleAlignFlags_ALIAS # = <StyleAlignFlags>{ <uint8_t>(StyleAlignFlags_END).bits }
   # 'flex-start'
   const StyleAlignFlags StyleAlignFlags_FLEX_START # = <StyleAlignFlags>{ <uint8_t>(1 << 3) }
+  const StyleAlignFlags StyleAlignFlags_MIXED # = <StyleAlignFlags>{ <uint8_t>(((1 << 4) | (StyleAlignFlags_FLEX_START).bits) | (StyleAlignFlags_END).bits) }
+  const StyleAlignFlags StyleAlignFlags_MIXED_SELF # = <StyleAlignFlags>{ <uint8_t>(((1 << 5) | (StyleAlignFlags_FLEX_START).bits) | (StyleAlignFlags_END).bits) }
 
   void root(StyleAlignFlags flags);
diff --git a/tests/expectations/bitflags.both.c b/tests/expectations/bitflags.both.c
index a4a86518a..8428299a2 100644
--- a/tests/expectations/bitflags.both.c
+++ b/tests/expectations/bitflags.both.c
@@ -27,10 +27,13 @@ typedef struct AlignFlags {
  * 'end'
  */
 #define AlignFlags_END (AlignFlags){ .bits = (uint8_t)(1 << 2) }
+#define AlignFlags_ALIAS (AlignFlags){ .bits = (uint8_t)(AlignFlags_END).bits }
 /**
  * 'flex-start'
  */
 #define AlignFlags_FLEX_START (AlignFlags){ .bits = (uint8_t)(1 << 3) }
+#define AlignFlags_MIXED (AlignFlags){ .bits = (uint8_t)(((1 << 4) | (AlignFlags_FLEX_START).bits) | (AlignFlags_END).bits) }
+#define AlignFlags_MIXED_SELF (AlignFlags){ .bits = (uint8_t)(((1 << 5) | (AlignFlags_FLEX_START).bits) | (AlignFlags_END).bits) }
 
 typedef struct DebugFlags {
   uint32_t bits;
diff --git a/tests/expectations/bitflags.both.compat.c b/tests/expectations/bitflags.both.compat.c
index 82d308e84..23b6243c0 100644
--- a/tests/expectations/bitflags.both.compat.c
+++ b/tests/expectations/bitflags.both.compat.c
@@ -27,10 +27,13 @@ typedef struct AlignFlags {
  * 'end'
  */
 #define AlignFlags_END (AlignFlags){ .bits = (uint8_t)(1 << 2) }
+#define AlignFlags_ALIAS (AlignFlags){ .bits = (uint8_t)(AlignFlags_END).bits }
 /**
  * 'flex-start'
  */
 #define AlignFlags_FLEX_START (AlignFlags){ .bits = (uint8_t)(1 << 3) }
+#define AlignFlags_MIXED (AlignFlags){ .bits = (uint8_t)(((1 << 4) | (AlignFlags_FLEX_START).bits) | (AlignFlags_END).bits) }
+#define AlignFlags_MIXED_SELF (AlignFlags){ .bits = (uint8_t)(((1 << 5) | (AlignFlags_FLEX_START).bits) | (AlignFlags_END).bits) }
 
 typedef struct DebugFlags {
   uint32_t bits;
diff --git a/tests/expectations/bitflags.c b/tests/expectations/bitflags.c
index bf9e4655e..073f10fbf 100644
--- a/tests/expectations/bitflags.c
+++ b/tests/expectations/bitflags.c
@@ -27,10 +27,13 @@ typedef struct {
  * 'end'
  */
 #define AlignFlags_END (AlignFlags){ .bits = (uint8_t)(1 << 2) }
+#define AlignFlags_ALIAS (AlignFlags){ .bits = (uint8_t)(AlignFlags_END).bits }
 /**
  * 'flex-start'
  */
 #define AlignFlags_FLEX_START (AlignFlags){ .bits = (uint8_t)(1 << 3) }
+#define AlignFlags_MIXED (AlignFlags){ .bits = (uint8_t)(((1 << 4) | (AlignFlags_FLEX_START).bits) | (AlignFlags_END).bits) }
+#define AlignFlags_MIXED_SELF (AlignFlags){ .bits = (uint8_t)(((1 << 5) | (AlignFlags_FLEX_START).bits) | (AlignFlags_END).bits) }
 
 typedef struct {
   uint32_t bits;
diff --git a/tests/expectations/bitflags.compat.c b/tests/expectations/bitflags.compat.c
index 672d93420..cbcf7c4a2 100644
--- a/tests/expectations/bitflags.compat.c
+++ b/tests/expectations/bitflags.compat.c
@@ -27,10 +27,13 @@ typedef struct {
  * 'end'
  */
 #define AlignFlags_END (AlignFlags){ .bits = (uint8_t)(1 << 2) }
+#define AlignFlags_ALIAS (AlignFlags){ .bits = (uint8_t)(AlignFlags_END).bits }
 /**
  * 'flex-start'
  */
 #define AlignFlags_FLEX_START (AlignFlags){ .bits = (uint8_t)(1 << 3) }
+#define AlignFlags_MIXED (AlignFlags){ .bits = (uint8_t)(((1 << 4) | (AlignFlags_FLEX_START).bits) | (AlignFlags_END).bits) }
+#define AlignFlags_MIXED_SELF (AlignFlags){ .bits = (uint8_t)(((1 << 5) | (AlignFlags_FLEX_START).bits) | (AlignFlags_END).bits) }
 
 typedef struct {
   uint32_t bits;
diff --git a/tests/expectations/bitflags.cpp b/tests/expectations/bitflags.cpp
index af131ae16..31cb63930 100644
--- a/tests/expectations/bitflags.cpp
+++ b/tests/expectations/bitflags.cpp
@@ -46,8 +46,11 @@ static const AlignFlags AlignFlags_NORMAL = AlignFlags{ /* .bits = */ (uint8_t)1
 static const AlignFlags AlignFlags_START = AlignFlags{ /* .bits = */ (uint8_t)(1 << 1) };
 /// 'end'
 static const AlignFlags AlignFlags_END = AlignFlags{ /* .bits = */ (uint8_t)(1 << 2) };
+static const AlignFlags AlignFlags_ALIAS = AlignFlags{ /* .bits = */ (uint8_t)(AlignFlags_END).bits };
 /// 'flex-start'
 static const AlignFlags AlignFlags_FLEX_START = AlignFlags{ /* .bits = */ (uint8_t)(1 << 3) };
+static const AlignFlags AlignFlags_MIXED = AlignFlags{ /* .bits = */ (uint8_t)(((1 << 4) | (AlignFlags_FLEX_START).bits) | (AlignFlags_END).bits) };
+static const AlignFlags AlignFlags_MIXED_SELF = AlignFlags{ /* .bits = */ (uint8_t)(((1 << 5) | (AlignFlags_FLEX_START).bits) | (AlignFlags_END).bits) };
 
 struct DebugFlags {
   uint32_t bits;
diff --git a/tests/expectations/bitflags.pyx b/tests/expectations/bitflags.pyx
index 138c99c54..fd33bdb6e 100644
--- a/tests/expectations/bitflags.pyx
+++ b/tests/expectations/bitflags.pyx
@@ -19,8 +19,11 @@ cdef extern from *:
   const AlignFlags AlignFlags_START # = <AlignFlags>{ <uint8_t>(1 << 1) }
   # 'end'
   const AlignFlags AlignFlags_END # = <AlignFlags>{ <uint8_t>(1 << 2) }
+  const AlignFlags AlignFlags_ALIAS # = <AlignFlags>{ <uint8_t>(AlignFlags_END).bits }
   # 'flex-start'
   const AlignFlags AlignFlags_FLEX_START # = <AlignFlags>{ <uint8_t>(1 << 3) }
+  const AlignFlags AlignFlags_MIXED # = <AlignFlags>{ <uint8_t>(((1 << 4) | (AlignFlags_FLEX_START).bits) | (AlignFlags_END).bits) }
+  const AlignFlags AlignFlags_MIXED_SELF # = <AlignFlags>{ <uint8_t>(((1 << 5) | (AlignFlags_FLEX_START).bits) | (AlignFlags_END).bits) }
 
   ctypedef struct DebugFlags:
     uint32_t bits;
diff --git a/tests/expectations/bitflags.tag.c b/tests/expectations/bitflags.tag.c
index 1b796fae0..13729091e 100644
--- a/tests/expectations/bitflags.tag.c
+++ b/tests/expectations/bitflags.tag.c
@@ -27,10 +27,13 @@ struct AlignFlags {
  * 'end'
  */
 #define AlignFlags_END (AlignFlags){ .bits = (uint8_t)(1 << 2) }
+#define AlignFlags_ALIAS (AlignFlags){ .bits = (uint8_t)(AlignFlags_END).bits }
 /**
  * 'flex-start'
  */
 #define AlignFlags_FLEX_START (AlignFlags){ .bits = (uint8_t)(1 << 3) }
+#define AlignFlags_MIXED (AlignFlags){ .bits = (uint8_t)(((1 << 4) | (AlignFlags_FLEX_START).bits) | (AlignFlags_END).bits) }
+#define AlignFlags_MIXED_SELF (AlignFlags){ .bits = (uint8_t)(((1 << 5) | (AlignFlags_FLEX_START).bits) | (AlignFlags_END).bits) }
 
 struct DebugFlags {
   uint32_t bits;
diff --git a/tests/expectations/bitflags.tag.compat.c b/tests/expectations/bitflags.tag.compat.c
index 1feb5c13d..6b6e2b8bb 100644
--- a/tests/expectations/bitflags.tag.compat.c
+++ b/tests/expectations/bitflags.tag.compat.c
@@ -27,10 +27,13 @@ struct AlignFlags {
  * 'end'
  */
 #define AlignFlags_END (AlignFlags){ .bits = (uint8_t)(1 << 2) }
+#define AlignFlags_ALIAS (AlignFlags){ .bits = (uint8_t)(AlignFlags_END).bits }
 /**
  * 'flex-start'
  */
 #define AlignFlags_FLEX_START (AlignFlags){ .bits = (uint8_t)(1 << 3) }
+#define AlignFlags_MIXED (AlignFlags){ .bits = (uint8_t)(((1 << 4) | (AlignFlags_FLEX_START).bits) | (AlignFlags_END).bits) }
+#define AlignFlags_MIXED_SELF (AlignFlags){ .bits = (uint8_t)(((1 << 5) | (AlignFlags_FLEX_START).bits) | (AlignFlags_END).bits) }
 
 struct DebugFlags {
   uint32_t bits;
diff --git a/tests/expectations/bitflags.tag.pyx b/tests/expectations/bitflags.tag.pyx
index d9d205fde..272cddca3 100644
--- a/tests/expectations/bitflags.tag.pyx
+++ b/tests/expectations/bitflags.tag.pyx
@@ -19,8 +19,11 @@ cdef extern from *:
   const AlignFlags AlignFlags_START # = <AlignFlags>{ <uint8_t>(1 << 1) }
   # 'end'
   const AlignFlags AlignFlags_END # = <AlignFlags>{ <uint8_t>(1 << 2) }
+  const AlignFlags AlignFlags_ALIAS # = <AlignFlags>{ <uint8_t>(AlignFlags_END).bits }
   # 'flex-start'
   const AlignFlags AlignFlags_FLEX_START # = <AlignFlags>{ <uint8_t>(1 << 3) }
+  const AlignFlags AlignFlags_MIXED # = <AlignFlags>{ <uint8_t>(((1 << 4) | (AlignFlags_FLEX_START).bits) | (AlignFlags_END).bits) }
+  const AlignFlags AlignFlags_MIXED_SELF # = <AlignFlags>{ <uint8_t>(((1 << 5) | (AlignFlags_FLEX_START).bits) | (AlignFlags_END).bits) }
 
   cdef struct DebugFlags:
     uint32_t bits;
diff --git a/tests/rust/associated_in_body.rs b/tests/rust/associated_in_body.rs
index 6c3fe4e21..0f0768196 100644
--- a/tests/rust/associated_in_body.rs
+++ b/tests/rust/associated_in_body.rs
@@ -2,7 +2,7 @@ bitflags! {
     /// Constants shared by multiple CSS Box Alignment properties
     ///
     /// These constants match Gecko's `NS_STYLE_ALIGN_*` constants.
-    #[derive(MallocSizeOf, ToComputedValue)]
+    #[derive(MallocSizeOf)]
     #[repr(C)]
     pub struct AlignFlags: u8 {
         /// 'auto'
@@ -13,8 +13,11 @@ bitflags! {
         const START = 1 << 1;
         /// 'end'
         const END = 1 << 2;
+        const ALIAS = Self::END.bits;
         /// 'flex-start'
         const FLEX_START = 1 << 3;
+        const MIXED = 1 << 4 | AlignFlags::FLEX_START.bits | AlignFlags::END.bits;
+        const MIXED_SELF = 1 << 5 | AlignFlags::FLEX_START.bits | AlignFlags::END.bits;
     }
 }
 
diff --git a/tests/rust/bitflags.rs b/tests/rust/bitflags.rs
index 017104a7c..013e10b6f 100644
--- a/tests/rust/bitflags.rs
+++ b/tests/rust/bitflags.rs
@@ -2,7 +2,7 @@ bitflags! {
     /// Constants shared by multiple CSS Box Alignment properties
     ///
     /// These constants match Gecko's `NS_STYLE_ALIGN_*` constants.
-    #[derive(MallocSizeOf, ToComputedValue)]
+    #[derive(MallocSizeOf)]
     #[repr(C)]
     pub struct AlignFlags: u8 {
         /// 'auto'
@@ -13,8 +13,11 @@ bitflags! {
         const START = 1 << 1;
         /// 'end'
         const END = 1 << 2;
+        const ALIAS = Self::END.bits;
         /// 'flex-start'
         const FLEX_START = 1 << 3;
+        const MIXED = 1 << 4 | AlignFlags::FLEX_START.bits | AlignFlags::END.bits;
+        const MIXED_SELF = 1 << 5 | AlignFlags::FLEX_START.bits | AlignFlags::END.bits;
     }
 }