Fix scope for LaTeX macros.

They should by default scope over the group in which they
are defined (except `\gdef` and `\xdef`, which are global).
In addition, environments must be treated as groups.

We handle this by making sMacros in the LaTeX parser state
a STACK of macro tables. Opening a group adds a table to
the stack, closing one removes one.  Only the top of the stack
is queried.

This commit adds a parameter for scope to the Macro constructor
(not exported).

Closes #7494.

1 files changed, 37 insertions, 12 deletions

diff --git a/src/Text/Pandoc/Readers/LaTeX/Parsing.hs b/src/Text/Pandoc/Readers/LaTeX/Parsing.hs
index 8d6791abb..e1b72926f 100644
--- a/src/Text/Pandoc/Readers/LaTeX/Parsing.hs
+++ b/src/Text/Pandoc/Readers/LaTeX/Parsing.hs
@@ -102,6 +102,9 @@ import qualified Data.IntMap as IntMap
 import qualified Data.Map as M
 import qualified Data.Set as Set
 import Data.Text (Text)
+import Data.Maybe (fromMaybe)
+import Data.List.NonEmpty (NonEmpty(..))
+import qualified Data.List.NonEmpty as NonEmpty
 import qualified Data.Text as T
 import Text.Pandoc.Builder
 import Text.Pandoc.Class.PandocMonad (PandocMonad, report)
@@ -146,7 +149,7 @@ data TheoremSpec =
 data LaTeXState = LaTeXState{ sOptions       :: ReaderOptions
                             , sMeta          :: Meta
                             , sQuoteContext  :: QuoteContext
-                            , sMacros        :: M.Map Text Macro
+                            , sMacros        :: NonEmpty (M.Map Text Macro)
                             , sContainers    :: [Text]
                             , sLogMessages   :: [LogMessage]
                             , sIdentifiers   :: Set.Set Text
@@ -173,7 +176,7 @@ defaultLaTeXState :: LaTeXState
 defaultLaTeXState = LaTeXState{ sOptions       = def
                               , sMeta          = nullMeta
                               , sQuoteContext  = NoQuote
-                              , sMacros        = M.empty
+                              , sMacros        = M.empty :| []
                               , sContainers    = []
                               , sLogMessages   = []
                               , sIdentifiers   = Set.empty
@@ -220,8 +223,9 @@ instance HasIncludeFiles LaTeXState where
   dropLatestIncludeFile s = s { sContainers = drop 1 $ sContainers s }
 
 instance HasMacros LaTeXState where
-  extractMacros  st  = sMacros st
-  updateMacros f st  = st{ sMacros = f (sMacros st) }
+  extractMacros  st  = NonEmpty.head $ sMacros st
+  updateMacros f st  = st{ sMacros = f (NonEmpty.head $ sMacros st)
+                                     :| (NonEmpty.tail $ sMacros st) }
 
 instance HasReaderOptions LaTeXState where
   extractReaderOptions = sOptions
@@ -254,7 +258,7 @@ rawLaTeXParser :: (PandocMonad m, HasMacros s, HasReaderOptions s, Show a)
 rawLaTeXParser toks retokenize parser valParser = do
   pstate <- getState
   let lstate = def{ sOptions = extractReaderOptions pstate }
-  let lstate' = lstate { sMacros = extractMacros pstate }
+  let lstate' = lstate { sMacros = extractMacros pstate :| [] }
   let setStartPos = case toks of
                       Tok pos _ _ : _ -> setPosition pos
                       _ -> return ()
@@ -274,7 +278,7 @@ rawLaTeXParser toks retokenize parser valParser = do
          case res of
               Left _    -> mzero
               Right ((val, raw), st) -> do
-                updateState (updateMacros (sMacros st <>))
+                updateState (updateMacros ((NonEmpty.head (sMacros st)) <>))
                 let skipTilPos stopPos = do
                       anyChar
                       pos <- getPosition
@@ -299,7 +303,7 @@ applyMacros s = (guardDisabled Ext_latex_macros >> return s) <|>
    do let retokenize = untokenize <$> many anyTok
       pstate <- getState
       let lstate = def{ sOptions = extractReaderOptions pstate
-                      , sMacros  = extractMacros pstate }
+                      , sMacros  = extractMacros pstate :| [] }
       res <- runParserT retokenize lstate "math" (tokenize "math" s)
       case res of
            Left e   -> Prelude.fail (show e)
@@ -552,10 +556,10 @@ doMacros' n inp =
     handleMacros n' spos name ts = do
       when (n' > 20)  -- detect macro expansion loops
         $ throwError $ PandocMacroLoop name
-      macros <- sMacros <$> getState
+      (macros :| _ ) <- sMacros <$> getState
       case M.lookup name macros of
            Nothing -> trySpecialMacro name ts
-           Just (Macro expansionPoint argspecs optarg newtoks) -> do
+           Just (Macro _scope expansionPoint argspecs optarg newtoks) -> do
              let getargs' = do
                    args <-
                      (case expansionPoint of
@@ -745,10 +749,22 @@ primEscape = do
 bgroup :: PandocMonad m => LP m Tok
 bgroup = try $ do
   optional sp
-  symbol '{' <|> controlSeq "bgroup" <|> controlSeq "begingroup"
+  t <- symbol '{' <|> controlSeq "bgroup" <|> controlSeq "begingroup"
+  -- Add a copy of the macro table to the top of the macro stack,
+  -- private for this group. We inherit all the macros defined in
+  -- the parent group.
+  updateState $ \s -> s{ sMacros = NonEmpty.cons (NonEmpty.head (sMacros s))
+                                                 (sMacros s) }
+  return t
+
 
 egroup :: PandocMonad m => LP m Tok
-egroup = symbol '}' <|> controlSeq "egroup" <|> controlSeq "endgroup"
+egroup = do
+  t <- symbol '}' <|> controlSeq "egroup" <|> controlSeq "endgroup"
+  -- remove the group's macro table from the stack
+  updateState $ \s -> s{ sMacros = fromMaybe (sMacros s) $
+      NonEmpty.nonEmpty (NonEmpty.tail (sMacros s)) }
+  return t
 
 grouped :: (PandocMonad m,  Monoid a) => LP m a -> LP m a
 grouped parser = try $ do
@@ -1017,7 +1033,16 @@ resetCaption = updateState $ \st -> st{ sCaption   = Nothing
                                       , sLastLabel = Nothing }
 
 env :: PandocMonad m => Text -> LP m a -> LP m a
-env name p = p <* end_ name
+env name p = do
+  -- environments are groups as far as macros are concerned,
+  -- so we need a local copy of the macro table (see above, bgroup, egroup):
+  updateState $ \s -> s{ sMacros = NonEmpty.cons (NonEmpty.head (sMacros s))
+                                                 (sMacros s) }
+  result <- p
+  updateState $ \s -> s{ sMacros = fromMaybe (sMacros s) $
+      NonEmpty.nonEmpty (NonEmpty.tail (sMacros s)) }
+  end_ name
+  return result
 
 tokWith :: PandocMonad m => LP m Inlines -> LP m Inlines
 tokWith inlineParser = try $ spaces >>