import OccName
import SrcLoc
import Type
+import Coercion
import TysWiredIn
import BasicTypes as Hs
import ForeignCall
; ty' <- cvtType ty
; return $ SpecSig nm' ty' (cvtInlineSpec opt_ispec) }
-cvtInlineSpec :: Maybe TH.InlineSpec -> Hs.InlineSpec
+cvtInlineSpec :: Maybe TH.InlineSpec -> Hs.InlinePragma
cvtInlineSpec Nothing
- = defaultInlineSpec
+ = defaultInlinePragma
cvtInlineSpec (Just (TH.InlineSpec inline conlike opt_activation))
- = mkInlineSpec opt_activation' matchinfo inline
+ = InlinePragma { inl_act = opt_activation', inl_rule = matchinfo
+ , inl_inline = inline, inl_sat = Nothing }
where
matchinfo = cvtRuleMatchInfo conlike
- opt_activation' = fmap cvtActivation opt_activation
+ opt_activation' = cvtActivation opt_activation
cvtRuleMatchInfo False = FunLike
cvtRuleMatchInfo True = ConLike
- cvtActivation (False, phase) = ActiveBefore phase
- cvtActivation (True , phase) = ActiveAfter phase
+ cvtActivation Nothing | inline = AlwaysActive
+ | otherwise = NeverActive
+ cvtActivation (Just (False, phase)) = ActiveBefore phase
+ cvtActivation (Just (True , phase)) = ActiveAfter phase
---------------------------------------------------
-- Declarations
allCharLs :: [TH.Exp] -> Maybe String
-- Note [Converting strings]
-allCharLs (LitE (CharL c) : xs)
- | Just cs <- allCharLs xs = Just (c:cs)
-allCharLs [] = Just []
-allCharLs _ = Nothing
+-- NB: only fire up this setup for a non-empty list, else
+-- there's a danger of returning "" for [] :: [Int]!
+allCharLs xs
+ = case xs of
+ LitE (CharL c) : ys -> go [c] ys
+ _ -> Nothing
+ where
+ go cs [] = Just (reverse cs)
+ go cs (LitE (CharL c) : ys) = go (c:cs) ys
+ go _ _ = Nothing
cvtLit :: Lit -> CvtM HsLit
cvtLit (IntPrimL i) = do { force i; return $ HsIntPrim i }
cvt_tv :: TH.TyVarBndr -> CvtM (LHsTyVarBndr RdrName)
cvt_tv (TH.PlainTV nm)
= do { nm' <- tName nm
- ; returnL $ UserTyVar nm'
+ ; returnL $ UserTyVar nm' placeHolderKind
}
cvt_tv (TH.KindedTV nm ki)
= do { nm' <- tName nm
mk_uniq_occ :: OccName.NameSpace -> String -> Int# -> OccName.OccName
mk_uniq_occ ns occ uniq
= OccName.mkOccName ns (occ ++ '[' : shows (mk_uniq uniq) "]")
- -- The idea here is to make a name that
- -- a) the user could not possibly write, and
- -- b) cannot clash with another NameU
- -- Previously I generated an Exact RdrName with mkInternalName.
- -- This works fine for local binders, but does not work at all for
- -- top-level binders, which must have External Names, since they are
- -- rapidly baked into data constructors and the like. Baling out
- -- and generating an unqualified RdrName here is the simple solution
+ -- See Note [Unique OccNames from Template Haskell]
-- The packing and unpacking is rather turgid :-(
mk_occ :: OccName.NameSpace -> String -> OccName.OccName
mk_uniq u = mkUniqueGrimily (I# u)
\end{code}
+Note [Unique OccNames from Template Haskell]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+The idea here is to make a name that
+ a) the user could not possibly write (it has a "["
+ and letters or digits from the unique)
+ b) cannot clash with another NameU
+Previously I generated an Exact RdrName with mkInternalName. This
+works fine for local binders, but does not work at all for top-level
+binders, which must have External Names, since they are rapidly baked
+into data constructors and the like. Baling out and generating an
+unqualified RdrName here is the simple solution
+
+See also Note [Suppressing uniques in OccNames] in OccName, which
+suppresses the unique when opt_SuppressUniques is on.