diff --git a/ChangeLog.md b/ChangeLog.md
--- a/ChangeLog.md
+++ b/ChangeLog.md
@@ -1,5 +1,10 @@
 # Revision history for th-abstraction
 
+## 0.2.4.0 -- 2017-07-31
+
+* Fix bug that caused GADT equality constraints to be incorrect in some cases.
+* Expose `Unpackedness` and `Strictness` (which were unexported by accident).
+
 ## 0.2.3.0 -- 2017-06-26
 
 * Add `resolvePredSynonyms`
diff --git a/src/Language/Haskell/TH/Datatype.hs b/src/Language/Haskell/TH/Datatype.hs
--- a/src/Language/Haskell/TH/Datatype.hs
+++ b/src/Language/Haskell/TH/Datatype.hs
@@ -60,6 +60,8 @@
   , DatatypeVariant(..)
   , ConstructorVariant(..)
   , FieldStrictness(..)
+  , Unpackedness(..)
+  , Strictness(..)
 
   -- * Normalization functions
   , reifyDatatype
@@ -106,6 +108,7 @@
   -- * Convenience functions
   , unifyTypes
   , tvName
+  , tvKind
   , datatypeType
   ) where
 
@@ -539,7 +542,7 @@
 
 -- If a VarT is missing an explicit kind signature, steal it from a TyVarBndr.
 stealKindForType :: TyVarBndr -> Type -> Type
-stealKindForType tvb t@VarT{} = SigT t (tvbKind tvb)
+stealKindForType tvb t@VarT{} = SigT t (tvKind tvb)
 stealKindForType _   t        = t
 
 -- | Normalize 'Dec' for a newtype or datatype into a 'DatatypeInfo'.
@@ -611,9 +614,9 @@
     PlainTV  t   -> VarT t
 
 -- | Extract the kind from a 'TyVarBndr'. Assumes 'PlainTV' has kind @*@.
-tvbKind :: TyVarBndr -> Kind
-tvbKind (PlainTV  _)   = starK
-tvbKind (KindedTV _ k) = k
+tvKind :: TyVarBndr -> Kind
+tvKind (PlainTV  _)   = starK
+tvKind (KindedTV _ k) = k
 
 -- | Remove the outermost 'SigT'.
 stripSigT :: Type -> Type
@@ -878,16 +881,36 @@
   Q [ConstructorInfo]
 normalizeGadtC typename params tyvars context names innerType
                fields stricts getVariant =
-  do innerType' <- resolveTypeSynonyms innerType
+  do -- Due to GHC Trac #13885, it's possible that the type variables bound by
+     -- a GADT constructor will shadow those that are bound by the data type.
+     -- This function assumes this isn't the case in certain parts (e.g., when
+     -- mergeArguments is invoked), so we do an alpha-renaming of the
+     -- constructor-bound variables before proceeding. See #36 for an example
+     -- of what can go wrong if this isn't done.
+     let conBoundNames =
+           concatMap (\tvb -> tvName tvb:freeVariables (tvKind tvb)) tyvars
+     conSubst <- T.sequence $ Map.fromList [ (n, newName (nameBase n))
+                                           | n <- conBoundNames ]
+     let conSubst'     = fmap VarT conSubst
+         renamedTyvars =
+           map (\tvb -> case tvb of
+                          PlainTV n    -> PlainTV  (conSubst Map.! n)
+                          KindedTV n k -> KindedTV (conSubst Map.! n)
+                                                   (applySubstitution conSubst' k)) tyvars
+         renamedContext   = applySubstitution conSubst' context
+         renamedInnerType = applySubstitution conSubst' innerType
+         renamedFields    = applySubstitution conSubst' fields
+
+     innerType' <- resolveTypeSynonyms renamedInnerType
      case decomposeType innerType' of
        ConT innerTyCon :| ts | typename == innerTyCon ->
 
          let (substName, context1) = mergeArguments params ts
              subst   = VarT <$> substName
-             tyvars' = [ tv | tv <- tyvars, Map.notMember (tvName tv) subst ]
+             tyvars' = [ tv | tv <- renamedTyvars, Map.notMember (tvName tv) subst ]
 
-             context2 = applySubstitution subst (context1 ++ context)
-             fields'  = applySubstitution subst fields
+             context2 = applySubstitution subst (context1 ++ renamedContext)
+             fields'  = applySubstitution subst renamedFields
          in sequence [ ConstructorInfo name tyvars' context2
                                        fields' stricts <$> variantQ
                      | name <- names
diff --git a/test/Main.hs b/test/Main.hs
--- a/test/Main.hs
+++ b/test/Main.hs
@@ -26,6 +26,10 @@
 import Control.Monad (zipWithM_)
 #endif
 
+#if MIN_VERSION_base(4,7,0)
+import Data.Type.Equality ((:~:)(..))
+#endif
+
 import Language.Haskell.TH
 import Language.Haskell.TH.Datatype
 import Language.Haskell.TH.Lib (starK)
@@ -62,6 +66,9 @@
 #endif
      reifyDatatypeWithConNameTest
      reifyConstructorTest
+#if MIN_VERSION_base(4,7,0)
+     importedEqualityTest
+#endif
 
 adt1Test :: IO ()
 adt1Test =
@@ -521,7 +528,6 @@
 reifyDatatypeWithConNameTest :: IO ()
 reifyDatatypeWithConNameTest =
   $(do info <- reifyDatatype 'Just
-       let a = VarT (mkName "a")
        validateDI info
          DatatypeInfo
           { datatypeContext = []
@@ -546,3 +552,30 @@
 reifyConstructorTest =
   $(do info <- reifyConstructor 'Just
        validateCI info justCI)
+
+#if MIN_VERSION_base(4,7,0)
+importedEqualityTest :: IO ()
+importedEqualityTest =
+  $(do info <- reifyDatatype ''(:~:)
+       let [a,b] = map (VarT . mkName) ["a","b"]
+           k     = mkName "k"
+           kKind = varKCompat k
+       validateDI info
+         DatatypeInfo
+           { datatypeContext = []
+           , datatypeName    = ''(:~:)
+           , datatypeVars    = [SigT a kKind, SigT b kKind]
+           , datatypeVariant = Datatype
+           , datatypeCons    =
+               [ ConstructorInfo
+                   { constructorName       = 'Refl
+                   , constructorVars       = [KindedTV k starK]
+                     -- This shouldn't happen, ideally. See #37.
+
+                   , constructorContext    = [equalPred a b]
+                   , constructorFields     = []
+                   , constructorStrictness = []
+                   , constructorVariant    = NormalConstructor } ]
+           }
+   )
+#endif
diff --git a/th-abstraction.cabal b/th-abstraction.cabal
--- a/th-abstraction.cabal
+++ b/th-abstraction.cabal
@@ -1,5 +1,5 @@
 name:                th-abstraction
-version:             0.2.3.0
+version:             0.2.4.0
 synopsis:            Nicer interface for reified information about data types
 description:         This package normalizes variations in the interface for
                      inspecting datatype information via Template Haskell