{-# Language FlexibleContexts, RecordWildCards, TypeFamilies #-}

-- | The programming languages Oberon and Oberon-2

module Language.Oberon (parseModule, parseAndResolveModule, parseAndResolveModuleFile,
                        LanguageVersion(..), Options(..), NodeWrap, Placed) where

import Language.Oberon.AST (Language, Module(..), Ident)
import qualified Language.Oberon.Grammar as Grammar
import qualified Language.Oberon.Resolver as Resolver
import qualified Language.Oberon.Reserializer as Reserializer
import qualified Language.Oberon.ConstantFolder as ConstantFolder
import qualified Language.Oberon.TypeChecker as TypeChecker
import Language.Oberon.Resolver (NodeWrap, Placed)

import qualified Transformation.Deep as Deep
import qualified Transformation.Full as Full

import Control.Monad (guard)
import Data.Either.Validation (Validation(..))
import Data.Functor.Compose (Compose(Compose, getCompose))
import Data.List.NonEmpty (NonEmpty((:|)))
import qualified Data.List.NonEmpty as NonEmpty
import qualified Data.Map.Lazy as Map
import Data.Map.Lazy (Map)
import Data.Monoid ((<>))
import Data.Text (Text, unpack)
import Data.Text.IO (readFile)
import Text.Grampa (Ambiguous(Ambiguous), Grammar, ParseResults, parseComplete, failureDescription)
import System.Directory (doesFileExist)
import System.FilePath (FilePath, addExtension, combine, takeDirectory)

import Prelude hiding (readFile)

data LanguageVersion = Oberon1 | Oberon2 deriving (LanguageVersion -> LanguageVersion -> Bool
(LanguageVersion -> LanguageVersion -> Bool)
-> (LanguageVersion -> LanguageVersion -> Bool)
-> Eq LanguageVersion
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: LanguageVersion -> LanguageVersion -> Bool
== :: LanguageVersion -> LanguageVersion -> Bool
$c/= :: LanguageVersion -> LanguageVersion -> Bool
/= :: LanguageVersion -> LanguageVersion -> Bool
Eq, Eq LanguageVersion
Eq LanguageVersion =>
(LanguageVersion -> LanguageVersion -> Ordering)
-> (LanguageVersion -> LanguageVersion -> Bool)
-> (LanguageVersion -> LanguageVersion -> Bool)
-> (LanguageVersion -> LanguageVersion -> Bool)
-> (LanguageVersion -> LanguageVersion -> Bool)
-> (LanguageVersion -> LanguageVersion -> LanguageVersion)
-> (LanguageVersion -> LanguageVersion -> LanguageVersion)
-> Ord LanguageVersion
LanguageVersion -> LanguageVersion -> Bool
LanguageVersion -> LanguageVersion -> Ordering
LanguageVersion -> LanguageVersion -> LanguageVersion
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: LanguageVersion -> LanguageVersion -> Ordering
compare :: LanguageVersion -> LanguageVersion -> Ordering
$c< :: LanguageVersion -> LanguageVersion -> Bool
< :: LanguageVersion -> LanguageVersion -> Bool
$c<= :: LanguageVersion -> LanguageVersion -> Bool
<= :: LanguageVersion -> LanguageVersion -> Bool
$c> :: LanguageVersion -> LanguageVersion -> Bool
> :: LanguageVersion -> LanguageVersion -> Bool
$c>= :: LanguageVersion -> LanguageVersion -> Bool
>= :: LanguageVersion -> LanguageVersion -> Bool
$cmax :: LanguageVersion -> LanguageVersion -> LanguageVersion
max :: LanguageVersion -> LanguageVersion -> LanguageVersion
$cmin :: LanguageVersion -> LanguageVersion -> LanguageVersion
min :: LanguageVersion -> LanguageVersion -> LanguageVersion
Ord, Int -> LanguageVersion -> ShowS
[LanguageVersion] -> ShowS
LanguageVersion -> String
(Int -> LanguageVersion -> ShowS)
-> (LanguageVersion -> String)
-> ([LanguageVersion] -> ShowS)
-> Show LanguageVersion
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> LanguageVersion -> ShowS
showsPrec :: Int -> LanguageVersion -> ShowS
$cshow :: LanguageVersion -> String
show :: LanguageVersion -> String
$cshowList :: [LanguageVersion] -> ShowS
showList :: [LanguageVersion] -> ShowS
Show)

-- | choice of modes of operation
data Options = Options{
   -- | whether to fold the constants
   Options -> Bool
foldConstants :: Bool,
   -- | whether to verify the types
   Options -> Bool
checkTypes :: Bool,
   -- | which language version?
   Options -> LanguageVersion
version :: LanguageVersion}

moduleGrammar :: LanguageVersion
-> Grammar (OberonGrammar Language NodeWrap) Parser Text
moduleGrammar LanguageVersion
Oberon1 = Grammar (OberonGrammar Language NodeWrap) Parser Text
Grammar.oberonGrammar
moduleGrammar LanguageVersion
Oberon2 = Grammar (OberonGrammar Language NodeWrap) Parser Text
Grammar.oberon2Grammar 

definitionGrammar :: LanguageVersion
-> Grammar (OberonGrammar Language NodeWrap) Parser Text
definitionGrammar LanguageVersion
Oberon1 = Grammar (OberonGrammar Language NodeWrap) Parser Text
Grammar.oberonDefinitionGrammar
definitionGrammar LanguageVersion
Oberon2 = Grammar (OberonGrammar Language NodeWrap) Parser Text
Grammar.oberon2DefinitionGrammar 

-- | Parse the given text of a single module, without resolving the syntactic ambiguities.
parseModule :: LanguageVersion -> Text -> ParseResults Text [NodeWrap (Module Language Language NodeWrap NodeWrap)]
parseModule :: LanguageVersion
-> Text
-> ParseResults
     Text
     [NodeWrap
        (Module
           Language
           Language
           (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
           (Compose
              ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))]
parseModule LanguageVersion
version Text
src =
  Compose
  (Either (ParseFailure Pos Text))
  []
  (NodeWrap
     (Module
        Language
        Language
        (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
        (Compose
           ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))))
-> ParseResults
     Text
     [NodeWrap
        (Module
           Language
           Language
           (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
           (Compose
              ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))]
forall {k1} {k2} (f :: k1 -> *) (g :: k2 -> k1) (a :: k2).
Compose f g a -> f (g a)
getCompose (Text
-> NodeWrap (Module Language Language NodeWrap NodeWrap)
-> NodeWrap
     (Module
        Language
        Language
        (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
        (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))
forall (p :: * -> *) (q :: * -> *)
       (g :: (* -> *) -> (* -> *) -> *).
(p ~ NodeWrap,
 q
 ~ Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)),
 Functor (Map p q) g) =>
Text -> p (g p p) -> q (g q q)
Resolver.resolvePositions Text
src (NodeWrap (Module Language Language NodeWrap NodeWrap)
 -> NodeWrap
      (Module
         Language
         Language
         (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
         (Compose
            ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))))
-> (([[Lexeme]],
     NodeWrap (Module Language Language NodeWrap NodeWrap))
    -> NodeWrap (Module Language Language NodeWrap NodeWrap))
-> ([[Lexeme]],
    NodeWrap (Module Language Language NodeWrap NodeWrap))
-> NodeWrap
     (Module
        Language
        Language
        (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
        (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([[Lexeme]], NodeWrap (Module Language Language NodeWrap NodeWrap))
-> NodeWrap (Module Language Language NodeWrap NodeWrap)
forall a b. (a, b) -> b
snd
              (([[Lexeme]],
  NodeWrap (Module Language Language NodeWrap NodeWrap))
 -> NodeWrap
      (Module
         Language
         Language
         (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
         (Compose
            ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))))
-> Compose
     (Either (ParseFailure Pos Text))
     []
     ([[Lexeme]], NodeWrap (Module Language Language NodeWrap NodeWrap))
-> Compose
     (Either (ParseFailure Pos Text))
     []
     (NodeWrap
        (Module
           Language
           Language
           (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
           (Compose
              ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Compose
  (Compose (Either (ParseFailure Pos Text)) [])
  ((,) [[Lexeme]])
  (NodeWrap (Module Language Language NodeWrap NodeWrap))
-> Compose
     (Either (ParseFailure Pos Text))
     []
     ([[Lexeme]], NodeWrap (Module Language Language NodeWrap NodeWrap))
forall {k1} {k2} (f :: k1 -> *) (g :: k2 -> k1) (a :: k2).
Compose f g a -> f (g a)
getCompose (Compose
   (Compose (Either (ParseFailure Pos Text)) [])
   ((,) [[Lexeme]])
   (NodeWrap (Module Language Language NodeWrap NodeWrap))
 -> Compose
      (Either (ParseFailure Pos Text))
      []
      ([[Lexeme]],
       NodeWrap (Module Language Language NodeWrap NodeWrap)))
-> Compose
     (Compose (Either (ParseFailure Pos Text)) [])
     ((,) [[Lexeme]])
     (NodeWrap (Module Language Language NodeWrap NodeWrap))
-> Compose
     (Either (ParseFailure Pos Text))
     []
     ([[Lexeme]], NodeWrap (Module Language Language NodeWrap NodeWrap))
forall a b. (a -> b) -> a -> b
$ OberonGrammar
  Language
  NodeWrap
  (Compose
     (Compose (Either (ParseFailure Pos Text)) []) ((,) [[Lexeme]]))
-> Compose
     (Compose (Either (ParseFailure Pos Text)) [])
     ((,) [[Lexeme]])
     (NodeWrap (Module Language Language NodeWrap NodeWrap))
forall l (f :: * -> *) (p :: * -> *).
OberonGrammar l f p -> p (f (Module l l f f))
Grammar.module_prod (OberonGrammar
   Language
   NodeWrap
   (Compose
      (Compose (Either (ParseFailure Pos Text)) []) ((,) [[Lexeme]]))
 -> Compose
      (Compose (Either (ParseFailure Pos Text)) [])
      ((,) [[Lexeme]])
      (NodeWrap (Module Language Language NodeWrap NodeWrap)))
-> OberonGrammar
     Language
     NodeWrap
     (Compose
        (Compose (Either (ParseFailure Pos Text)) []) ((,) [[Lexeme]]))
-> Compose
     (Compose (Either (ParseFailure Pos Text)) [])
     ((,) [[Lexeme]])
     (NodeWrap (Module Language Language NodeWrap NodeWrap))
forall a b. (a -> b) -> a -> b
$ Grammar (OberonGrammar Language NodeWrap) Parser Text
-> Text
-> OberonGrammar
     Language
     NodeWrap
     (ResultFunctor (Parser (OberonGrammar Language NodeWrap) Text))
forall s (g :: (* -> *) -> *).
(ParserInput (Parser (OberonGrammar Language NodeWrap) Text) ~ s,
 GrammarConstraint
   (Parser (OberonGrammar Language NodeWrap) Text) g,
 Eq s, FactorialMonoid s) =>
g (Parser (OberonGrammar Language NodeWrap) Text)
-> s
-> g (ResultFunctor
        (Parser (OberonGrammar Language NodeWrap) Text))
forall (m :: * -> *) s (g :: (* -> *) -> *).
(MultiParsing m, ParserInput m ~ s, GrammarConstraint m g, Eq s,
 FactorialMonoid s) =>
g m -> s -> g (ResultFunctor m)
parseComplete (LanguageVersion
-> Grammar (OberonGrammar Language NodeWrap) Parser Text
moduleGrammar LanguageVersion
version) Text
src))

-- | Parse the given text of a single /definition/ module, without resolving the syntactic ambiguities.
parseDefinitionModule :: LanguageVersion -> Text
                      -> ParseResults Text [NodeWrap (Module Language Language NodeWrap NodeWrap)]
parseDefinitionModule :: LanguageVersion
-> Text
-> ParseResults
     Text
     [NodeWrap
        (Module
           Language
           Language
           (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
           (Compose
              ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))]
parseDefinitionModule LanguageVersion
version Text
src =
  Compose
  (Either (ParseFailure Pos Text))
  []
  (NodeWrap
     (Module
        Language
        Language
        (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
        (Compose
           ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))))
-> ParseResults
     Text
     [NodeWrap
        (Module
           Language
           Language
           (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
           (Compose
              ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))]
forall {k1} {k2} (f :: k1 -> *) (g :: k2 -> k1) (a :: k2).
Compose f g a -> f (g a)
getCompose (Text
-> NodeWrap (Module Language Language NodeWrap NodeWrap)
-> NodeWrap
     (Module
        Language
        Language
        (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
        (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))
forall (p :: * -> *) (q :: * -> *)
       (g :: (* -> *) -> (* -> *) -> *).
(p ~ NodeWrap,
 q
 ~ Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)),
 Functor (Map p q) g) =>
Text -> p (g p p) -> q (g q q)
Resolver.resolvePositions Text
src (NodeWrap (Module Language Language NodeWrap NodeWrap)
 -> NodeWrap
      (Module
         Language
         Language
         (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
         (Compose
            ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))))
-> (([[Lexeme]],
     NodeWrap (Module Language Language NodeWrap NodeWrap))
    -> NodeWrap (Module Language Language NodeWrap NodeWrap))
-> ([[Lexeme]],
    NodeWrap (Module Language Language NodeWrap NodeWrap))
-> NodeWrap
     (Module
        Language
        Language
        (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
        (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([[Lexeme]], NodeWrap (Module Language Language NodeWrap NodeWrap))
-> NodeWrap (Module Language Language NodeWrap NodeWrap)
forall a b. (a, b) -> b
snd
              (([[Lexeme]],
  NodeWrap (Module Language Language NodeWrap NodeWrap))
 -> NodeWrap
      (Module
         Language
         Language
         (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
         (Compose
            ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))))
-> Compose
     (Either (ParseFailure Pos Text))
     []
     ([[Lexeme]], NodeWrap (Module Language Language NodeWrap NodeWrap))
-> Compose
     (Either (ParseFailure Pos Text))
     []
     (NodeWrap
        (Module
           Language
           Language
           (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
           (Compose
              ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Compose
  (Compose (Either (ParseFailure Pos Text)) [])
  ((,) [[Lexeme]])
  (NodeWrap (Module Language Language NodeWrap NodeWrap))
-> Compose
     (Either (ParseFailure Pos Text))
     []
     ([[Lexeme]], NodeWrap (Module Language Language NodeWrap NodeWrap))
forall {k1} {k2} (f :: k1 -> *) (g :: k2 -> k1) (a :: k2).
Compose f g a -> f (g a)
getCompose (Compose
   (Compose (Either (ParseFailure Pos Text)) [])
   ((,) [[Lexeme]])
   (NodeWrap (Module Language Language NodeWrap NodeWrap))
 -> Compose
      (Either (ParseFailure Pos Text))
      []
      ([[Lexeme]],
       NodeWrap (Module Language Language NodeWrap NodeWrap)))
-> Compose
     (Compose (Either (ParseFailure Pos Text)) [])
     ((,) [[Lexeme]])
     (NodeWrap (Module Language Language NodeWrap NodeWrap))
-> Compose
     (Either (ParseFailure Pos Text))
     []
     ([[Lexeme]], NodeWrap (Module Language Language NodeWrap NodeWrap))
forall a b. (a -> b) -> a -> b
$ OberonGrammar
  Language
  NodeWrap
  (Compose
     (Compose (Either (ParseFailure Pos Text)) []) ((,) [[Lexeme]]))
-> Compose
     (Compose (Either (ParseFailure Pos Text)) [])
     ((,) [[Lexeme]])
     (NodeWrap (Module Language Language NodeWrap NodeWrap))
forall l (f :: * -> *) (p :: * -> *).
OberonGrammar l f p -> p (f (Module l l f f))
Grammar.module_prod (OberonGrammar
   Language
   NodeWrap
   (Compose
      (Compose (Either (ParseFailure Pos Text)) []) ((,) [[Lexeme]]))
 -> Compose
      (Compose (Either (ParseFailure Pos Text)) [])
      ((,) [[Lexeme]])
      (NodeWrap (Module Language Language NodeWrap NodeWrap)))
-> OberonGrammar
     Language
     NodeWrap
     (Compose
        (Compose (Either (ParseFailure Pos Text)) []) ((,) [[Lexeme]]))
-> Compose
     (Compose (Either (ParseFailure Pos Text)) [])
     ((,) [[Lexeme]])
     (NodeWrap (Module Language Language NodeWrap NodeWrap))
forall a b. (a -> b) -> a -> b
$ Grammar (OberonGrammar Language NodeWrap) Parser Text
-> Text
-> OberonGrammar
     Language
     NodeWrap
     (ResultFunctor (Parser (OberonGrammar Language NodeWrap) Text))
forall s (g :: (* -> *) -> *).
(ParserInput (Parser (OberonGrammar Language NodeWrap) Text) ~ s,
 GrammarConstraint
   (Parser (OberonGrammar Language NodeWrap) Text) g,
 Eq s, FactorialMonoid s) =>
g (Parser (OberonGrammar Language NodeWrap) Text)
-> s
-> g (ResultFunctor
        (Parser (OberonGrammar Language NodeWrap) Text))
forall (m :: * -> *) s (g :: (* -> *) -> *).
(MultiParsing m, ParserInput m ~ s, GrammarConstraint m g, Eq s,
 FactorialMonoid s) =>
g m -> s -> g (ResultFunctor m)
parseComplete (LanguageVersion
-> Grammar (OberonGrammar Language NodeWrap) Parser Text
definitionGrammar LanguageVersion
version) Text
src))

parseNamedModule :: LanguageVersion -> FilePath -> Text
                 -> IO (ParseResults Text [NodeWrap (Module Language Language NodeWrap NodeWrap)])
parseNamedModule :: LanguageVersion
-> String
-> Text
-> IO
     (ParseResults
        Text
        [NodeWrap
           (Module
              Language
              Language
              (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
              (Compose
                 ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))])
parseNamedModule LanguageVersion
version String
path Text
name =
   do let basePath :: String
basePath = String -> ShowS
combine String
path (Text -> String
unpack Text
name)
      Bool
isDefn <- String -> IO Bool
doesFileExist (String -> ShowS
addExtension String
basePath String
"Def")
      let grammar :: Grammar (OberonGrammar Language NodeWrap) Parser Text
grammar = (if Bool
isDefn then LanguageVersion
-> Grammar (OberonGrammar Language NodeWrap) Parser Text
definitionGrammar else LanguageVersion
-> Grammar (OberonGrammar Language NodeWrap) Parser Text
moduleGrammar) LanguageVersion
version
      Text
src <- String -> IO Text
readFile (String -> ShowS
addExtension String
basePath ShowS -> ShowS
forall a b. (a -> b) -> a -> b
$ if Bool
isDefn then String
"Def" else String
"Mod")
      ParseResults
  Text
  [NodeWrap
     (Module
        Language
        Language
        (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
        (Compose
           ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))]
-> IO
     (ParseResults
        Text
        [NodeWrap
           (Module
              Language
              Language
              (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
              (Compose
                 ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))])
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Compose
  (Either (ParseFailure Pos Text))
  []
  (NodeWrap
     (Module
        Language
        Language
        (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
        (Compose
           ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))))
-> ParseResults
     Text
     [NodeWrap
        (Module
           Language
           Language
           (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
           (Compose
              ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))]
forall {k1} {k2} (f :: k1 -> *) (g :: k2 -> k1) (a :: k2).
Compose f g a -> f (g a)
getCompose (Compose
   (Either (ParseFailure Pos Text))
   []
   (NodeWrap
      (Module
         Language
         Language
         (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
         (Compose
            ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))))
 -> ParseResults
      Text
      [NodeWrap
         (Module
            Language
            Language
            (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
            (Compose
               ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))])
-> Compose
     (Either (ParseFailure Pos Text))
     []
     (NodeWrap
        (Module
           Language
           Language
           (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
           (Compose
              ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))))
-> ParseResults
     Text
     [NodeWrap
        (Module
           Language
           Language
           (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
           (Compose
              ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))]
forall a b. (a -> b) -> a -> b
$ Text
-> NodeWrap (Module Language Language NodeWrap NodeWrap)
-> NodeWrap
     (Module
        Language
        Language
        (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
        (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))
forall (p :: * -> *) (q :: * -> *)
       (g :: (* -> *) -> (* -> *) -> *).
(p ~ NodeWrap,
 q
 ~ Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)),
 Functor (Map p q) g) =>
Text -> p (g p p) -> q (g q q)
Resolver.resolvePositions Text
src (NodeWrap (Module Language Language NodeWrap NodeWrap)
 -> NodeWrap
      (Module
         Language
         Language
         (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
         (Compose
            ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))))
-> (([[Lexeme]],
     NodeWrap (Module Language Language NodeWrap NodeWrap))
    -> NodeWrap (Module Language Language NodeWrap NodeWrap))
-> ([[Lexeme]],
    NodeWrap (Module Language Language NodeWrap NodeWrap))
-> NodeWrap
     (Module
        Language
        Language
        (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
        (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([[Lexeme]], NodeWrap (Module Language Language NodeWrap NodeWrap))
-> NodeWrap (Module Language Language NodeWrap NodeWrap)
forall a b. (a, b) -> b
snd
                           (([[Lexeme]],
  NodeWrap (Module Language Language NodeWrap NodeWrap))
 -> NodeWrap
      (Module
         Language
         Language
         (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
         (Compose
            ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))))
-> Compose
     (Either (ParseFailure Pos Text))
     []
     ([[Lexeme]], NodeWrap (Module Language Language NodeWrap NodeWrap))
-> Compose
     (Either (ParseFailure Pos Text))
     []
     (NodeWrap
        (Module
           Language
           Language
           (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
           (Compose
              ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Compose
  (Compose (Either (ParseFailure Pos Text)) [])
  ((,) [[Lexeme]])
  (NodeWrap (Module Language Language NodeWrap NodeWrap))
-> Compose
     (Either (ParseFailure Pos Text))
     []
     ([[Lexeme]], NodeWrap (Module Language Language NodeWrap NodeWrap))
forall {k1} {k2} (f :: k1 -> *) (g :: k2 -> k1) (a :: k2).
Compose f g a -> f (g a)
getCompose (Compose
   (Compose (Either (ParseFailure Pos Text)) [])
   ((,) [[Lexeme]])
   (NodeWrap (Module Language Language NodeWrap NodeWrap))
 -> Compose
      (Either (ParseFailure Pos Text))
      []
      ([[Lexeme]],
       NodeWrap (Module Language Language NodeWrap NodeWrap)))
-> Compose
     (Compose (Either (ParseFailure Pos Text)) [])
     ((,) [[Lexeme]])
     (NodeWrap (Module Language Language NodeWrap NodeWrap))
-> Compose
     (Either (ParseFailure Pos Text))
     []
     ([[Lexeme]], NodeWrap (Module Language Language NodeWrap NodeWrap))
forall a b. (a -> b) -> a -> b
$ OberonGrammar
  Language
  NodeWrap
  (Compose
     (Compose (Either (ParseFailure Pos Text)) []) ((,) [[Lexeme]]))
-> Compose
     (Compose (Either (ParseFailure Pos Text)) [])
     ((,) [[Lexeme]])
     (NodeWrap (Module Language Language NodeWrap NodeWrap))
forall l (f :: * -> *) (p :: * -> *).
OberonGrammar l f p -> p (f (Module l l f f))
Grammar.module_prod (OberonGrammar
   Language
   NodeWrap
   (Compose
      (Compose (Either (ParseFailure Pos Text)) []) ((,) [[Lexeme]]))
 -> Compose
      (Compose (Either (ParseFailure Pos Text)) [])
      ((,) [[Lexeme]])
      (NodeWrap (Module Language Language NodeWrap NodeWrap)))
-> OberonGrammar
     Language
     NodeWrap
     (Compose
        (Compose (Either (ParseFailure Pos Text)) []) ((,) [[Lexeme]]))
-> Compose
     (Compose (Either (ParseFailure Pos Text)) [])
     ((,) [[Lexeme]])
     (NodeWrap (Module Language Language NodeWrap NodeWrap))
forall a b. (a -> b) -> a -> b
$ Grammar (OberonGrammar Language NodeWrap) Parser Text
-> Text
-> OberonGrammar
     Language
     NodeWrap
     (ResultFunctor (Parser (OberonGrammar Language NodeWrap) Text))
forall s (g :: (* -> *) -> *).
(ParserInput (Parser (OberonGrammar Language NodeWrap) Text) ~ s,
 GrammarConstraint
   (Parser (OberonGrammar Language NodeWrap) Text) g,
 Eq s, FactorialMonoid s) =>
g (Parser (OberonGrammar Language NodeWrap) Text)
-> s
-> g (ResultFunctor
        (Parser (OberonGrammar Language NodeWrap) Text))
forall (m :: * -> *) s (g :: (* -> *) -> *).
(MultiParsing m, ParserInput m ~ s, GrammarConstraint m g, Eq s,
 FactorialMonoid s) =>
g m -> s -> g (ResultFunctor m)
parseComplete Grammar (OberonGrammar Language NodeWrap) Parser Text
grammar Text
src))

parseImportsOf :: LanguageVersion -> FilePath -> Map Text (NodeWrap (Module Language Language NodeWrap NodeWrap))
               -> IO (Map Text (NodeWrap (Module Language Language NodeWrap NodeWrap)))
parseImportsOf :: LanguageVersion
-> String
-> Map
     Text
     (NodeWrap
        (Module
           Language
           Language
           (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
           (Compose
              ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))))
-> IO
     (Map
        Text
        (NodeWrap
           (Module
              Language
              Language
              (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
              (Compose
                 ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))))
parseImportsOf LanguageVersion
version String
path Map
  Text
  (NodeWrap
     (Module
        Language
        Language
        (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
        (Compose
           ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))))
modules =
   case (Text -> Bool) -> [Text] -> [Text]
forall a. (a -> Bool) -> [a] -> [a]
filter (Text
-> Map
     Text
     (NodeWrap
        (Module
           Language
           Language
           (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
           (Compose
              ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))))
-> Bool
forall k a. Ord k => k -> Map k a -> Bool
`Map.notMember` Map
  Text
  (NodeWrap
     (Module
        Language
        Language
        (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
        (Compose
           ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))))
modules) [Text]
moduleImports
   of [] -> Map
  Text
  (NodeWrap
     (Module
        Language
        Language
        (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
        (Compose
           ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))))
-> IO
     (Map
        Text
        (NodeWrap
           (Module
              Language
              Language
              (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
              (Compose
                 ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))))
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Map
  Text
  (NodeWrap
     (Module
        Language
        Language
        (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
        (Compose
           ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))))
modules
      [Text]
newImports -> (((Map
  Text
  (NodeWrap
     (Module
        Language
        Language
        (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
        (Compose
           ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))))
modules Map
  Text
  (NodeWrap
     (Module
        Language
        Language
        (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
        (Compose
           ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))))
-> Map
     Text
     (NodeWrap
        (Module
           Language
           Language
           (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
           (Compose
              ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))))
-> Map
     Text
     (NodeWrap
        (Module
           Language
           Language
           (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
           (Compose
              ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))))
forall a. Semigroup a => a -> a -> a
<>) (Map
   Text
   (NodeWrap
      (Module
         Language
         Language
         (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
         (Compose
            ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))))
 -> Map
      Text
      (NodeWrap
         (Module
            Language
            Language
            (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
            (Compose
               ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))))
-> ([(Text,
      ParseResults
        Text
        [NodeWrap
           (Module
              Language
              Language
              (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
              (Compose
                 ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))])]
    -> Map
         Text
         (NodeWrap
            (Module
               Language
               Language
               (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
               (Compose
                  ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))))
-> [(Text,
     ParseResults
       Text
       [NodeWrap
          (Module
             Language
             Language
             (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
             (Compose
                ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))])]
-> Map
     Text
     (NodeWrap
        (Module
           Language
           Language
           (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
           (Compose
              ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(Text,
  NodeWrap
    (Module
       Language
       Language
       (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
       (Compose
          ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))))]
-> Map
     Text
     (NodeWrap
        (Module
           Language
           Language
           (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
           (Compose
              ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))))
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList ([(Text,
   NodeWrap
     (Module
        Language
        Language
        (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
        (Compose
           ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))))]
 -> Map
      Text
      (NodeWrap
         (Module
            Language
            Language
            (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
            (Compose
               ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))))
-> ([(Text,
      ParseResults
        Text
        [NodeWrap
           (Module
              Language
              Language
              (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
              (Compose
                 ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))])]
    -> [(Text,
         NodeWrap
           (Module
              Language
              Language
              (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
              (Compose
                 ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))))])
-> [(Text,
     ParseResults
       Text
       [NodeWrap
          (Module
             Language
             Language
             (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
             (Compose
                ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))])]
-> Map
     Text
     (NodeWrap
        (Module
           Language
           Language
           (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
           (Compose
              ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Text,
  ParseResults
    Text
    [NodeWrap
       (Module
          Language
          Language
          (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
          (Compose
             ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))])
 -> (Text,
     NodeWrap
       (Module
          Language
          Language
          (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
          (Compose
             ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))))
-> [(Text,
     ParseResults
       Text
       [NodeWrap
          (Module
             Language
             Language
             (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
             (Compose
                ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))])]
-> [(Text,
     NodeWrap
       (Module
          Language
          Language
          (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
          (Compose
             ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))))]
forall a b. (a -> b) -> [a] -> [b]
map (Text,
 ParseResults
   Text
   [NodeWrap
      (Module
         Language
         Language
         (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
         (Compose
            ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))])
-> (Text,
    NodeWrap
      (Module
         Language
         Language
         (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
         (Compose
            ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))))
forall {a} {b}. (Text, Either a [b]) -> (Text, b)
assertSuccess) ([(Text,
   ParseResults
     Text
     [NodeWrap
        (Module
           Language
           Language
           (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
           (Compose
              ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))])]
 -> Map
      Text
      (NodeWrap
         (Module
            Language
            Language
            (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
            (Compose
               ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))))
-> IO
     [(Text,
       ParseResults
         Text
         [NodeWrap
            (Module
               Language
               Language
               (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
               (Compose
                  ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))])]
-> IO
     (Map
        Text
        (NodeWrap
           (Module
              Language
              Language
              (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
              (Compose
                 ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                     (((Text, Text)
 -> IO
      (Text,
       ParseResults
         Text
         [NodeWrap
            (Module
               Language
               Language
               (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
               (Compose
                  ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))]))
-> [(Text, Text)]
-> IO
     [(Text,
       ParseResults
         Text
         [NodeWrap
            (Module
               Language
               Language
               (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
               (Compose
                  ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))])]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse (((Text, Text)
  -> IO
       (Text,
        ParseResults
          Text
          [NodeWrap
             (Module
                Language
                Language
                (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
                (Compose
                   ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))]))
 -> [(Text, Text)]
 -> IO
      [(Text,
        ParseResults
          Text
          [NodeWrap
             (Module
                Language
                Language
                (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
                (Compose
                   ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))])])
-> ((Text
     -> IO
          (ParseResults
             Text
             [NodeWrap
                (Module
                   Language
                   Language
                   (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
                   (Compose
                      ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))]))
    -> (Text, Text)
    -> IO
         (Text,
          ParseResults
            Text
            [NodeWrap
               (Module
                  Language
                  Language
                  (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
                  (Compose
                     ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))]))
-> (Text
    -> IO
         (ParseResults
            Text
            [NodeWrap
               (Module
                  Language
                  Language
                  (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
                  (Compose
                     ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))]))
-> [(Text, Text)]
-> IO
     [(Text,
       ParseResults
         Text
         [NodeWrap
            (Module
               Language
               Language
               (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
               (Compose
                  ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))])]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Text
 -> IO
      (ParseResults
         Text
         [NodeWrap
            (Module
               Language
               Language
               (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
               (Compose
                  ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))]))
-> (Text, Text)
-> IO
     (Text,
      ParseResults
        Text
        [NodeWrap
           (Module
              Language
              Language
              (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
              (Compose
                 ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))])
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> (Text, a) -> f (Text, b)
traverse) (LanguageVersion
-> String
-> Text
-> IO
     (ParseResults
        Text
        [NodeWrap
           (Module
              Language
              Language
              (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
              (Compose
                 ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))])
parseNamedModule LanguageVersion
version String
path) [(Text
p, Text
p) | Text
p <- [Text]
newImports])
                    IO
  (Map
     Text
     (NodeWrap
        (Module
           Language
           Language
           (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
           (Compose
              ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))))
-> (Map
      Text
      (NodeWrap
         (Module
            Language
            Language
            (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
            (Compose
               ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))))
    -> IO
         (Map
            Text
            (NodeWrap
               (Module
                  Language
                  Language
                  (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
                  (Compose
                     ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))))))
-> IO
     (Map
        Text
        (NodeWrap
           (Module
              Language
              Language
              (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
              (Compose
                 ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))))
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= LanguageVersion
-> String
-> Map
     Text
     (NodeWrap
        (Module
           Language
           Language
           (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
           (Compose
              ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))))
-> IO
     (Map
        Text
        (NodeWrap
           (Module
              Language
              Language
              (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
              (Compose
                 ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))))
parseImportsOf LanguageVersion
version String
path
   where moduleImports :: [Text]
moduleImports = (Module
   Language
   Language
   (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
   (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
 -> [Text])
-> Compose
     (Map Text)
     (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
     (Module
        Language
        Language
        (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
        (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))
-> [Text]
forall m a.
Monoid m =>
(a -> m)
-> Compose
     (Map Text)
     (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
     a
-> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap Module
  Language
  Language
  (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
  (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
-> [Text]
forall {λ} {l} {f' :: * -> *} {f :: * -> *}.
Module λ l f' f -> [Text]
importsOf (Map
  Text
  (NodeWrap
     (Module
        Language
        Language
        (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
        (Compose
           ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))))
-> Compose
     (Map Text)
     (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
     (Module
        Language
        Language
        (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
        (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))
forall {k} {k1} (f :: k -> *) (g :: k1 -> k) (a :: k1).
f (g a) -> Compose f g a
Compose Map
  Text
  (NodeWrap
     (Module
        Language
        Language
        (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
        (Compose
           ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))))
modules)
         importsOf :: Module λ l f' f -> [Text]
importsOf (Module Text
_ [Import l]
imports f (Block l l f' f')
_) = Import l -> Text
forall a b. (a, b) -> b
snd (Import l -> Text) -> [Import l] -> [Text]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Import l]
imports
         assertSuccess :: (Text, Either a [b]) -> (Text, b)
assertSuccess (Text
m, Left a
err) = String -> (Text, b)
forall a. HasCallStack => String -> a
error (String
"Parse error in module " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> Text -> String
unpack Text
m)
         assertSuccess (Text
m, Right [b
p]) = (Text
m, b
p)
         assertSuccess (Text
m, Right [b]
_) = String -> (Text, b)
forall a. HasCallStack => String -> a
error (String
"Ambiguous parses of module " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> Text -> String
unpack Text
m)

-- | Given a directory path for module imports, parse the given module text and all the module files it imports, then
-- use all the information to resolve the syntactic ambiguities.
parseAndResolveModule :: Options -> FilePath -> Text
                      -> IO (Validation (Either (NonEmpty (Resolver.Error Language))
                                                (NonEmpty (TypeChecker.Error Ident Language)))
                                        (Placed (Module Language Language Placed Placed)))
parseAndResolveModule :: Options
-> String
-> Text
-> IO
     (Validation
        (Either
           (NonEmpty (Error Language)) (NonEmpty (Error Text Language)))
        (Placed (Module Language Language Parsed Parsed)))
parseAndResolveModule Options{Bool
LanguageVersion
foldConstants :: Options -> Bool
checkTypes :: Options -> Bool
version :: Options -> LanguageVersion
foldConstants :: Bool
checkTypes :: Bool
version :: LanguageVersion
..} String
path Text
source =
   case LanguageVersion
-> Text
-> ParseResults
     Text
     [NodeWrap
        (Module
           Language
           Language
           (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
           (Compose
              ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))]
parseModule LanguageVersion
version Text
source
   of Left ParseFailure Pos Text
err -> Validation
  (Either
     (NonEmpty (Error Language)) (NonEmpty (Error Text Language)))
  (Placed (Module Language Language Parsed Parsed))
-> IO
     (Validation
        (Either
           (NonEmpty (Error Language)) (NonEmpty (Error Text Language)))
        (Placed (Module Language Language Parsed Parsed)))
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Either (NonEmpty (Error Language)) (NonEmpty (Error Text Language))
-> Validation
     (Either
        (NonEmpty (Error Language)) (NonEmpty (Error Text Language)))
     (Placed (Module Language Language Parsed Parsed))
forall e a. e -> Validation e a
Failure (Either
   (NonEmpty (Error Language)) (NonEmpty (Error Text Language))
 -> Validation
      (Either
         (NonEmpty (Error Language)) (NonEmpty (Error Text Language)))
      (Placed (Module Language Language Parsed Parsed)))
-> Either
     (NonEmpty (Error Language)) (NonEmpty (Error Text Language))
-> Validation
     (Either
        (NonEmpty (Error Language)) (NonEmpty (Error Text Language)))
     (Placed (Module Language Language Parsed Parsed))
forall a b. (a -> b) -> a -> b
$ NonEmpty (Error Language)
-> Either
     (NonEmpty (Error Language)) (NonEmpty (Error Text Language))
forall a b. a -> Either a b
Left (NonEmpty (Error Language)
 -> Either
      (NonEmpty (Error Language)) (NonEmpty (Error Text Language)))
-> NonEmpty (Error Language)
-> Either
     (NonEmpty (Error Language)) (NonEmpty (Error Text Language))
forall a b. (a -> b) -> a -> b
$ Text -> Error Language
forall l. Text -> Error l
Resolver.UnparseableModule (Text -> ParseFailure Pos Text -> Int -> Text
forall s pos.
(Ord s, TextualMonoid s, Position pos) =>
s -> ParseFailure pos s -> Int -> s
failureDescription Text
source ParseFailure Pos Text
err Int
4) Error Language -> [Error Language] -> NonEmpty (Error Language)
forall a. a -> [a] -> NonEmpty a
:| [])
      Right [rootModule :: NodeWrap
  (Module
     Language
     Language
     (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
     (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))
rootModule@(Compose ((Int, Int)
pos, Compose (Ambiguous ((ParsedLexemes
_, Module Text
moduleName [Import l]
imports NodeWrap
  (Block
     Language
     Language
     (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
     (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))
_) :| []))))] ->
         do Map
  Text
  (NodeWrap
     (Module
        Language
        Language
        (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
        (Compose
           ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))))
importedModules <- LanguageVersion
-> String
-> Map
     Text
     (NodeWrap
        (Module
           Language
           Language
           (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
           (Compose
              ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))))
-> IO
     (Map
        Text
        (NodeWrap
           (Module
              Language
              Language
              (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
              (Compose
                 ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))))
parseImportsOf LanguageVersion
version String
path (Text
-> NodeWrap
     (Module
        Language
        Language
        (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
        (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))
-> Map
     Text
     (NodeWrap
        (Module
           Language
           Language
           (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
           (Compose
              ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))))
forall k a. k -> a -> Map k a
Map.singleton Text
moduleName NodeWrap
  (Module
     Language
     Language
     (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
     (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))
rootModule)
            let resolvedImportMap :: Map
  Text
  (Validation
     (NonEmpty (Error Language))
     (Placed (Module Language Language Parsed Parsed)))
resolvedImportMap = Scope Language
-> Map
     Text
     (Validation
        (NonEmpty (Error Language))
        (Placed (Module Language Language Parsed Parsed)))
-> NodeWrap
     (Module
        Language
        Language
        (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
        (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))
-> Validation
     (NonEmpty (Error Language))
     (Placed (Module Language Language Parsed Parsed))
forall l.
(BindableDeclaration l, CoFormalParameters l,
 Traversable (Resolution l) (Module l l),
 Traversable (Resolution l) (Block l l),
 Traversable (Resolution l) (Declaration l l),
 Traversable (Resolution l) (Type l l),
 Traversable (Resolution l) (FormalParameters l l),
 Traversable (Resolution l) (ConstExpression l l),
 Traversable (Resolution l) (StatementSequence l l),
 Traversable (Resolution l) (Declaration l l),
 Traversable (Resolution l) (DeclarationRHS l),
 Traversable (Resolution l) (Declaration l l),
 Traversable (Resolution l) (StatementSequence l l),
 Traversable (Resolution l) (Type l l),
 Traversable (Resolution l) (FormalParameters l l),
 Traversable (Resolution l) (ConstExpression l l),
 At
   (Resolution l)
   (Block
      l
      l
      (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
      (Compose
         ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))) =>
Scope l
-> Map
     Text
     (Validation
        (NonEmpty (Error l)) (Placed (Module l l Parsed Parsed)))
-> NodeWrap
     (Module
        l
        l
        (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
        (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))
-> Validation
     (NonEmpty (Error l)) (Placed (Module l l Parsed Parsed))
Resolver.resolveModule Scope Language
predefinedScope Map
  Text
  (Validation
     (NonEmpty (Error Language))
     (Placed (Module Language Language Parsed Parsed)))
resolvedImportMap (NodeWrap
   (Module
      Language
      Language
      (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
      (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))
 -> Validation
      (NonEmpty (Error Language))
      (Placed (Module Language Language Parsed Parsed)))
-> Map
     Text
     (NodeWrap
        (Module
           Language
           Language
           (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
           (Compose
              ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))))
-> Map
     Text
     (Validation
        (NonEmpty (Error Language))
        (Placed (Module Language Language Parsed Parsed)))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Map
  Text
  (NodeWrap
     (Module
        Language
        Language
        (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
        (Compose
           ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))))
importedModules
                predefinedScope :: Scope Language
predefinedScope = case LanguageVersion
version 
                                  of LanguageVersion
Oberon1 -> Scope Language
forall l. Oberon l => Predefined l
Resolver.predefined
                                     LanguageVersion
Oberon2 -> Scope Language
forall l. Oberon l => Predefined l
Resolver.predefined2
                successful :: Validation e a -> Maybe a
successful (Success a
a) = a -> Maybe a
forall a. a -> Maybe a
Just a
a
                successful Validation e a
_ = Maybe a
forall a. Maybe a
Nothing
                addLeft :: Validation a a -> Validation (Either a b) a
addLeft (Failure a
resolutionErrors) = Either a b -> Validation (Either a b) a
forall e a. e -> Validation e a
Failure (a -> Either a b
forall a b. a -> Either a b
Left a
resolutionErrors)
                addLeft (Success a
result) = a -> Validation (Either a b) a
forall e a. a -> Validation e a
Success a
result
                constantFolded :: Map Text (Placed (Module Language Language Parsed Parsed))
constantFolded = Placed (Module Language Language Parsed Parsed)
-> Placed (Module Language Language Parsed Parsed)
forall (g :: (* -> *) -> (* -> *) -> *).
(Foldable (g (Const (Sum Int))),
 Foldable (Fold Parsed (Sum Int)) g,
 Traversable PositionAdjustment g) =>
Parsed (g Parsed Parsed) -> Parsed (g Parsed Parsed)
Reserializer.adjustPositions (Placed (Module Language Language Parsed Parsed)
 -> Placed (Module Language Language Parsed Parsed))
-> Map Text (Placed (Module Language Language Parsed Parsed))
-> Map Text (Placed (Module Language Language Parsed Parsed))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                                 Environment Language
-> Map Text (Placed (Module Language Language Parsed Parsed))
-> Map Text (Placed (Module Language Language Parsed Parsed))
forall l.
(Oberon l, Nameable l, Ord (QualIdent l), Show (QualIdent l),
 Atts (Inherited (Auto ConstantFold)) (Block l l Sem Sem) ~ InhCF l,
 Atts (Synthesized (Auto ConstantFold)) (Block l l Sem Sem)
 ~ SynCFMod' l (Block l l),
 Functor (Auto ConstantFold) (Block l l),
 Functor (Auto ConstantFold) (Block l l)) =>
Environment l
-> Map Text (Placed (Module l l Parsed Parsed))
-> Map Text (Placed (Module l l Parsed Parsed))
ConstantFolder.foldConstants
                                    (case LanguageVersion
version
                                     of LanguageVersion
Oberon1 -> Environment Language
forall l. (Wirthy l, Ord (QualIdent l)) => Environment l
ConstantFolder.predefined
                                        LanguageVersion
Oberon2 -> Environment Language
forall l. (Wirthy l, Ord (QualIdent l)) => Environment l
ConstantFolder.predefined2)
                                    ((Validation
   (NonEmpty (Error Language))
   (Placed (Module Language Language Parsed Parsed))
 -> Maybe (Placed (Module Language Language Parsed Parsed)))
-> Map
     Text
     (Validation
        (NonEmpty (Error Language))
        (Placed (Module Language Language Parsed Parsed)))
-> Map Text (Placed (Module Language Language Parsed Parsed))
forall a b k. (a -> Maybe b) -> Map k a -> Map k b
Map.mapMaybe Validation
  (NonEmpty (Error Language))
  (Placed (Module Language Language Parsed Parsed))
-> Maybe (Placed (Module Language Language Parsed Parsed))
forall {e} {a}. Validation e a -> Maybe a
successful Map
  Text
  (Validation
     (NonEmpty (Error Language))
     (Placed (Module Language Language Parsed Parsed)))
resolvedImportMap)
                typeErrors :: [Error Text Language]
typeErrors = Environment Language
-> Map Text (Placed (Module Language Language Parsed Parsed))
-> [Error Text Language]
forall l.
(Oberon l, Nameable l, Ord (QualIdent l), Show (QualIdent l),
 Atts (Inherited (Auto TypeCheck)) (Block l l Sem Sem) ~ InhTC l,
 Atts (Synthesized (Auto TypeCheck)) (Block l l Sem Sem)
 ~ SynTCMod l,
 Functor (Auto TypeCheck) (Block l l)) =>
Environment l
-> Map Text (Placed (Module l l Parsed Parsed)) -> [Error Text l]
TypeChecker.checkModules
                                (case LanguageVersion
version 
                                 of LanguageVersion
Oberon1 -> Environment Language
forall l. (Wirthy l, Ord (QualIdent l)) => Environment l
TypeChecker.predefined
                                    LanguageVersion
Oberon2 -> Environment Language
forall l. (Wirthy l, Ord (QualIdent l)) => Environment l
TypeChecker.predefined2)
                                Map Text (Placed (Module Language Language Parsed Parsed))
constantFolded
            Validation
  (Either
     (NonEmpty (Error Language)) (NonEmpty (Error Text Language)))
  (Placed (Module Language Language Parsed Parsed))
-> IO
     (Validation
        (Either
           (NonEmpty (Error Language)) (NonEmpty (Error Text Language)))
        (Placed (Module Language Language Parsed Parsed)))
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (if Bool
checkTypes Bool -> Bool -> Bool
&& Bool -> Bool
not ([Error Text Language] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Error Text Language]
typeErrors)
                    then Either (NonEmpty (Error Language)) (NonEmpty (Error Text Language))
-> Validation
     (Either
        (NonEmpty (Error Language)) (NonEmpty (Error Text Language)))
     (Placed (Module Language Language Parsed Parsed))
forall e a. e -> Validation e a
Failure (NonEmpty (Error Text Language)
-> Either
     (NonEmpty (Error Language)) (NonEmpty (Error Text Language))
forall a b. b -> Either a b
Right ([Error Text Language] -> NonEmpty (Error Text Language)
forall a. HasCallStack => [a] -> NonEmpty a
NonEmpty.fromList [Error Text Language]
typeErrors))
                    else Validation
  (Either
     (NonEmpty (Error Language)) (NonEmpty (Error Text Language)))
  (Placed (Module Language Language Parsed Parsed))
-> (Placed (Module Language Language Parsed Parsed)
    -> Validation
         (Either
            (NonEmpty (Error Language)) (NonEmpty (Error Text Language)))
         (Placed (Module Language Language Parsed Parsed)))
-> Maybe (Placed (Module Language Language Parsed Parsed))
-> Validation
     (Either
        (NonEmpty (Error Language)) (NonEmpty (Error Text Language)))
     (Placed (Module Language Language Parsed Parsed))
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (Validation
  (NonEmpty (Error Language))
  (Placed (Module Language Language Parsed Parsed))
-> Validation
     (Either
        (NonEmpty (Error Language)) (NonEmpty (Error Text Language)))
     (Placed (Module Language Language Parsed Parsed))
forall {a} {a} {b}. Validation a a -> Validation (Either a b) a
addLeft (Validation
   (NonEmpty (Error Language))
   (Placed (Module Language Language Parsed Parsed))
 -> Validation
      (Either
         (NonEmpty (Error Language)) (NonEmpty (Error Text Language)))
      (Placed (Module Language Language Parsed Parsed)))
-> Validation
     (NonEmpty (Error Language))
     (Placed (Module Language Language Parsed Parsed))
-> Validation
     (Either
        (NonEmpty (Error Language)) (NonEmpty (Error Text Language)))
     (Placed (Module Language Language Parsed Parsed))
forall a b. (a -> b) -> a -> b
$ Map
  Text
  (Validation
     (NonEmpty (Error Language))
     (Placed (Module Language Language Parsed Parsed)))
resolvedImportMap Map
  Text
  (Validation
     (NonEmpty (Error Language))
     (Placed (Module Language Language Parsed Parsed)))
-> Text
-> Validation
     (NonEmpty (Error Language))
     (Placed (Module Language Language Parsed Parsed))
forall k a. Ord k => Map k a -> k -> a
Map.! Text
moduleName) Placed (Module Language Language Parsed Parsed)
-> Validation
     (Either
        (NonEmpty (Error Language)) (NonEmpty (Error Text Language)))
     (Placed (Module Language Language Parsed Parsed))
forall e a. a -> Validation e a
Success
                         (Bool -> Maybe ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard Bool
foldConstants Maybe ()
-> Maybe (Placed (Module Language Language Parsed Parsed))
-> Maybe (Placed (Module Language Language Parsed Parsed))
forall a b. Maybe a -> Maybe b -> Maybe b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Text
-> Map Text (Placed (Module Language Language Parsed Parsed))
-> Maybe (Placed (Module Language Language Parsed Parsed))
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup Text
moduleName Map Text (Placed (Module Language Language Parsed Parsed))
constantFolded))
      Right [NodeWrap
   (Module
      Language
      Language
      (Compose ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes)))
      (Compose
         ((,) (Int, Int)) (Compose Ambiguous ((,) ParsedLexemes))))]
_ -> Validation
  (Either
     (NonEmpty (Error Language)) (NonEmpty (Error Text Language)))
  (Placed (Module Language Language Parsed Parsed))
-> IO
     (Validation
        (Either
           (NonEmpty (Error Language)) (NonEmpty (Error Text Language)))
        (Placed (Module Language Language Parsed Parsed)))
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Either (NonEmpty (Error Language)) (NonEmpty (Error Text Language))
-> Validation
     (Either
        (NonEmpty (Error Language)) (NonEmpty (Error Text Language)))
     (Placed (Module Language Language Parsed Parsed))
forall e a. e -> Validation e a
Failure (Either
   (NonEmpty (Error Language)) (NonEmpty (Error Text Language))
 -> Validation
      (Either
         (NonEmpty (Error Language)) (NonEmpty (Error Text Language)))
      (Placed (Module Language Language Parsed Parsed)))
-> Either
     (NonEmpty (Error Language)) (NonEmpty (Error Text Language))
-> Validation
     (Either
        (NonEmpty (Error Language)) (NonEmpty (Error Text Language)))
     (Placed (Module Language Language Parsed Parsed))
forall a b. (a -> b) -> a -> b
$ NonEmpty (Error Language)
-> Either
     (NonEmpty (Error Language)) (NonEmpty (Error Text Language))
forall a b. a -> Either a b
Left (NonEmpty (Error Language)
 -> Either
      (NonEmpty (Error Language)) (NonEmpty (Error Text Language)))
-> NonEmpty (Error Language)
-> Either
     (NonEmpty (Error Language)) (NonEmpty (Error Text Language))
forall a b. (a -> b) -> a -> b
$ Error Language
forall l. Error l
Resolver.AmbiguousParses Error Language -> [Error Language] -> NonEmpty (Error Language)
forall a. a -> [a] -> NonEmpty a
:| [])

-- | Parse the module file at the given path, assuming all its imports are in the same directory.
parseAndResolveModuleFile :: Options -> FilePath
                          -> IO (Validation (Either (NonEmpty (Resolver.Error Language))
                                                    (NonEmpty (TypeChecker.Error Ident Language)))
                                            (Placed (Module Language Language Placed Placed)))
parseAndResolveModuleFile :: Options
-> String
-> IO
     (Validation
        (Either
           (NonEmpty (Error Language)) (NonEmpty (Error Text Language)))
        (Placed (Module Language Language Parsed Parsed)))
parseAndResolveModuleFile Options
options String
path =
  String -> IO Text
readFile String
path IO Text
-> (Text
    -> IO
         (Validation
            (Either
               (NonEmpty (Error Language)) (NonEmpty (Error Text Language)))
            (Placed (Module Language Language Parsed Parsed))))
-> IO
     (Validation
        (Either
           (NonEmpty (Error Language)) (NonEmpty (Error Text Language)))
        (Placed (Module Language Language Parsed Parsed)))
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Options
-> String
-> Text
-> IO
     (Validation
        (Either
           (NonEmpty (Error Language)) (NonEmpty (Error Text Language)))
        (Placed (Module Language Language Parsed Parsed)))
parseAndResolveModule Options
options (ShowS
takeDirectory String
path)