feat: improve Pandoc check — 44→46 modules passing, fix loader CPP/diagnostics, char literal lexing, nested where clauses

- Lexer: disambiguate `'['` as char literal vs promoted list by lookahead
  for closing quote (fixes Text.Pandoc.Writers.Roff)
- Loader: add CPP preprocessing for imported modules (was only done in
  driver, causing parse failures when loading CPP-using modules as deps)
- Loader: treat parser diagnostics as non-fatal — only fail if module
  couldn't be parsed at all, matching driver behavior
- Lowering: fix where-clause scoping for multi-equation functions nested
  in where clauses — per-clause where bindings were silently ignored
  (fixes Text.Pandoc.Chunks from cascading lowering failure)
- AST: add TupleSections to Extension enum; classify ~30 common GHC
  extensions as accepted in status() to suppress unknown warnings
- Driver: add TypeErrorWithInfo error variant so type-check failures
  register exports and don't cascade to downstream modules
- Stubs: add missing exports for Skylighting (sName, sShortname,
  parseTheme), Text.Collate.Lang (record fields), Data.Yaml
  (decodeAllEither'), Data.Aeson.TH (camelTo2)
- Type checker: polymorphic Semigroup/Monoid, expanded builtin stubs,
  cross-module type alias propagation

Author: raffaelschneider

.claude/ROADMAP.md

@@ -3,7 +3,10 @@
 **Document ID:** BHC-TODO-PANDOC
 **Status:** In Progress
 **Created:** 2026-01-30
-**Updated:** 2026-02-27
+**Updated:** 2026-03-04
+
+**See also:** [ROADMAP.md](ROADMAP.md) — GHC boot library vs third-party package
+classification and milestone plan (P1–P5).
 
 ---
 

.claude/TODO-pandoc.md

@@ -190,6 +190,8 @@ pub enum Extension {
     NamedFieldPuns,
     /// Overloaded strings
     OverloadedStrings,
+    /// Tuple sections
+    TupleSections,
     /// Overloaded lists
     OverloadedLists,
     /// Numeric underscores
@@ -309,6 +311,7 @@ impl Extension {
             | Self::RecordWildCards
             | Self::NamedFieldPuns
             | Self::OverloadedStrings
+            | Self::TupleSections
             | Self::OverloadedLists
             | Self::NumericUnderscores
             | Self::BinaryLiterals
@@ -356,8 +359,26 @@ impl Extension {
             | Self::QuasiQuotes
             | Self::NamedDefaults => ExtensionStatus::Unimplemented,
 
-            // Unknown
-            Self::Unknown(_) => ExtensionStatus::Unknown,
+            // Unknown — check if it's a recognized GHC extension we silently accept
+            Self::Unknown(name) => {
+                match name.as_str() {
+                    // Common GHC extensions we silently accept for compatibility
+                    "Arrows" | "MonoLocalBinds" | "ImpredicativeTypes"
+                    | "TypeFamilyDependencies" | "DeriveAnyClass" | "RoleAnnotations"
+                    | "AllowAmbiguousTypes" | "TypeSynonymInstances" | "PackageImports"
+                    | "NoImplicitPrelude" | "NoMonomorphismRestriction"
+                    | "DisambiguateRecordFields" | "DuplicateRecordFields"
+                    | "ApplicativeDo" | "NumDecimals" | "MagicHash"
+                    | "UnboxedTuples" | "TypeInType" | "PolyKinds"
+                    | "StarIsType" | "ImportQualifiedPost"
+                    | "StandaloneKindSignatures" | "QuantifiedConstraints"
+                    | "LinearTypes" | "UnicodeSyntax" | "ParallelListComp"
+                    | "TransformListComp" | "MonadComprehensions"
+                    | "ExtendedDefaultRules" | "PostfixOperators"
+                    | "ScopedTypeVariables" | "NoFieldSelectors" => ExtensionStatus::Supported,
+                    _ => ExtensionStatus::Unknown,
+                }
+            }
         }
     }
 
@@ -392,6 +413,7 @@ impl Extension {
             "RecordWildCards" => Self::RecordWildCards,
             "NamedFieldPuns" => Self::NamedFieldPuns,
             "OverloadedStrings" => Self::OverloadedStrings,
+            "TupleSections" => Self::TupleSections,
             "OverloadedLists" => Self::OverloadedLists,
             "NumericUnderscores" => Self::NumericUnderscores,
             "HexFloatLiterals" => Self::HexFloatLiterals,

crates/bhc-ast/src/lib.rs

@@ -19,6 +19,7 @@ bhc-hir = { workspace = true }
 bhc-lower = { workspace = true }
 bhc-hir-to-core = { workspace = true }
 bhc-typeck = { workspace = true }
+bhc-types = { workspace = true }
 bhc-intern = { workspace = true }
 
 # Internal crates - IR pipeline

crates/bhc-driver/Cargo.toml

@@ -112,6 +112,16 @@ pub enum CompileError {
     #[error("type checking failed: {0} errors")]
     TypeError(usize),
 
+    /// Type checking failed but module exports are still available.
+    /// This allows downstream modules to continue checking.
+    #[error("type checking failed: {count} errors")]
+    TypeErrorWithInfo {
+        /// Number of type errors.
+        count: usize,
+        /// Module info with exports (available because HIR parsed/lowered successfully).
+        info: CompiledModuleInfo,
+    },
+
     /// HIR to Core lowering failed.
     #[error("core lowering failed: {0}")]
     CoreLowerError(#[from] bhc_hir_to_core::LowerError),
@@ -281,6 +291,8 @@ pub struct CompiledModuleInfo {
     pub symbols: Vec<CompiledSymbol>,
     /// Module exports for feeding into the lowering context of later modules.
     pub exports: ModuleExports,
+    /// Type aliases defined in this module, for cross-module alias expansion.
+    pub type_aliases: Vec<(bhc_intern::Symbol, Vec<bhc_types::TyVar>, bhc_types::Ty)>,
 }
 
 /// Accumulates compilation artifacts across modules during multi-module compilation.
@@ -1392,6 +1404,7 @@ impl Compiler {
             module_name: module_name.to_string(),
             symbols: compiled_symbols,
             exports,
+            type_aliases: Vec::new(),
         };
 
         Ok((object_path, compiled_info))
@@ -1545,16 +1558,59 @@ impl Compiler {
         // Phase 2: Lower AST to HIR with registry context
         let (hir, lower_ctx) = self.lower_with_registry(&ast, registry)?;
 
-        // Phase 3: Type check HIR
-        let _typed = self.type_check(&hir, file_id, &lower_ctx)?;
+        // Phase 3: Collect type aliases from imported modules
+        let mut imported_aliases = Vec::new();
+        for (_mod_name, info) in &registry.modules {
+            for (name, params, ty) in &info.type_aliases {
+                imported_aliases.push((*name, params.clone(), ty.clone()));
+            }
+        }
 
-        // Build exports for downstream modules (no Core IR needed)
+        // Phase 4: Type check HIR with imported type aliases
+        let type_errors = match bhc_typeck::type_check_module_full(&hir, file_id, Some(&lower_ctx.defs), &imported_aliases) {
+            Ok(_typed) => None,
+            Err(diagnostics) => {
+                eprintln!("Type errors:");
+                for (i, diag) in diagnostics.iter().enumerate() {
+                    eprintln!("  {}: {}", i + 1, diag.message);
+                }
+                Some(diagnostics.len())
+            }
+        };
+
+        // Build exports for downstream modules (no Core IR needed).
+        // We build exports even if type checking failed, since exports come from
+        // the HIR (which parsed and lowered successfully). This allows downstream
+        // modules to still be checked rather than being skipped entirely.
         let exports = Self::build_module_exports_from_hir(module_name, &hir, &lower_ctx);
 
+        // Extract type aliases for cross-module propagation
+        let mut type_aliases = Vec::new();
+        for item in &hir.items {
+            if let bhc_hir::Item::TypeAlias(alias) = item {
+                type_aliases.push((alias.name, alias.params.clone(), alias.ty.clone()));
+            }
+        }
+
+        // If there were type errors, return both the compiled info and the error.
+        // The caller can still register exports while reporting the failure.
+        if let Some(count) = type_errors {
+            return Err(CompileError::TypeErrorWithInfo {
+                count,
+                info: CompiledModuleInfo {
+                    module_name: module_name.to_string(),
+                    symbols: Vec::new(),
+                    exports,
+                    type_aliases,
+                },
+            });
+        }
+
         Ok(CompiledModuleInfo {
             module_name: module_name.to_string(),
             symbols: Vec::new(),
             exports,
+            type_aliases,
         })
     }
 
@@ -2877,6 +2933,7 @@ impl Compiler {
             "Foreign.C",
             "Foreign.C.Types",
             "Foreign.C.String",
+            "Foreign.C.Error",
             "Foreign.Storable",
             "Foreign.Marshal",
             "Foreign.Marshal.Alloc",
@@ -3220,7 +3277,9 @@ impl Compiler {
                 continue;
             }
 
-            // Skip if any local dependency failed
+            // Skip if any local dependency failed to parse/lower (not type-check).
+            // Type-check failures don't block downstream: those modules still have
+            // their exports registered in the registry via TypeErrorWithInfo below.
             let dep_failed = imports
                 .iter()
                 .any(|imp| failed_modules.contains(imp.as_str()));
@@ -3241,6 +3300,15 @@ impl Compiler {
                     registry.modules.insert(mod_name.clone(), compiled_info);
                     results.push((mod_name.clone(), Ok(())));
                 }
+                Err(CompileError::TypeErrorWithInfo { count, info }) => {
+                    // Type checking failed, but parsing and lowering succeeded.
+                    // Register the module's exports so downstream modules can
+                    // still be checked (they won't be skipped due to dependency failure).
+                    registry.modules.insert(mod_name.clone(), info);
+                    // Still mark as failed for reporting purposes, but do NOT
+                    // add to failed_modules so downstream modules aren't skipped.
+                    results.push((mod_name.clone(), Err(CompileError::TypeError(count))));
+                }
                 Err(e) => {
                     failed_modules.insert(mod_name.clone());
                     results.push((mod_name.clone(), Err(e)));

crates/bhc-driver/src/lib.rs

@@ -988,10 +988,15 @@ impl<'src> Lexer<'src> {
     fn lex_char(&mut self, _start: usize) -> Token {
         self.advance(); // Opening '
 
-        // M9: Check for promoted list syntax '[
+        // M9: Check for promoted list syntax '[ vs char literal '['
         if self.peek() == Some('[') {
-            self.advance();
-            return Token::new(TokenKind::TickLBracket);
+            // Lookahead: '[' followed by closing quote means char literal '['
+            if self.peek2() == Some('\'') {
+                // It's the char literal '[' — fall through to normal char handling
+            } else {
+                self.advance();
+                return Token::new(TokenKind::TickLBracket);
+            }
         }
 
         let c = match self.peek() {

crates/bhc-lexer/src/lib.rs

@@ -95,7 +95,7 @@ pub struct Scope {
     /// Parent scope, if any.
     pub parent: Option<ScopeId>,
     /// Value bindings (variables, functions).
-    values: FxHashMap<Symbol, DefId>,
+    pub values: FxHashMap<Symbol, DefId>,
     /// Type bindings (types, type constructors).
     types: FxHashMap<Symbol, DefId>,
     /// Constructor bindings.
@@ -1814,6 +1814,13 @@ impl LowerContext {
             "Full",
             // System.Locale
             "LocaleCategory",
+            // Text.Parsec
+            "SourcePos",
+            "ParsecT",
+            "ParseError",
+            // Network.URI
+            "URI",
+            "URIAuth",
         ];
 
         for name in stub_types {
@@ -2320,6 +2327,16 @@ impl LowerContext {
         &self.scopes[self.current_scope.index()]
     }
 
+    /// Gets the current scope ID (for debugging).
+    pub fn current_scope_id(&self) -> ScopeId {
+        self.current_scope
+    }
+
+    /// Gets all scopes (for debugging).
+    pub fn all_scopes(&self) -> &[Scope] {
+        &self.scopes
+    }
+
     /// Gets the current scope mutably.
     pub fn current_scope_mut(&mut self) -> &mut Scope {
         let idx = self.current_scope.index();
@@ -2441,26 +2458,36 @@ impl LowerContext {
     ///
     /// Returns the DefId if found, or None if not resolvable.
     pub fn resolve_qualified_var(&self, qualifier: Symbol, name: Symbol) -> Option<DefId> {
-        // First, check if the qualifier is an alias
-        let module = self
-            .import_aliases
-            .get(&qualifier)
-            .copied()
-            .unwrap_or(qualifier);
-
-        // Try to look up as "Module.name"
-        let qualified_name = Symbol::intern(&format!("{}.{}", module.as_str(), name.as_str()));
-
-        // Check if we have a qualified name mapping
-        if let Some(unqualified) = self.qualified_names.get(&qualified_name) {
+        // First, try direct lookup of "Qualifier.name" as registered during import processing.
+        // This handles cases where multiple modules share the same qualifier alias
+        // (e.g., `import qualified Data.Text as T` and `import qualified Data.Text.Encoding as T`).
+        let aliased_name = Symbol::intern(&format!("{}.{}", qualifier.as_str(), name.as_str()));
+        if let Some(def_id) = self.lookup_value(aliased_name) {
+            return Some(def_id);
+        }
+
+        // Check if we have a qualified name mapping for the aliased name
+        if let Some(unqualified) = self.qualified_names.get(&aliased_name) {
             if let Some(def_id) = self.lookup_value(*unqualified) {
                 return Some(def_id);
             }
         }
 
-        // Try direct lookup of the qualified name
-        if let Some(def_id) = self.lookup_value(qualified_name) {
-            return Some(def_id);
+        // Then, check if the qualifier is an alias and try the full module name
+        if let Some(&module) = self.import_aliases.get(&qualifier) {
+            let qualified_name = Symbol::intern(&format!("{}.{}", module.as_str(), name.as_str()));
+
+            // Check if we have a qualified name mapping
+            if let Some(unqualified) = self.qualified_names.get(&qualified_name) {
+                if let Some(def_id) = self.lookup_value(*unqualified) {
+                    return Some(def_id);
+                }
+            }
+
+            // Try direct lookup of the qualified name
+            if let Some(def_id) = self.lookup_value(qualified_name) {
+                return Some(def_id);
+            }
         }
 
         // Try looking up the unqualified name directly (for builtins)
@@ -2471,26 +2498,32 @@ impl LowerContext {
     ///
     /// Returns the DefId if found, or None if not resolvable.
     pub fn resolve_qualified_constructor(&self, qualifier: Symbol, name: Symbol) -> Option<DefId> {
-        // First, check if the qualifier is an alias
-        let module = self
-            .import_aliases
-            .get(&qualifier)
-            .copied()
-            .unwrap_or(qualifier);
-
-        // Try to look up as "Module.Name"
-        let qualified_name = Symbol::intern(&format!("{}.{}", module.as_str(), name.as_str()));
-
-        // Check if we have a qualified name mapping
-        if let Some(unqualified) = self.qualified_names.get(&qualified_name) {
+        // First, try direct lookup of "Qualifier.Name" as registered during import processing.
+        let aliased_name = Symbol::intern(&format!("{}.{}", qualifier.as_str(), name.as_str()));
+        if let Some(def_id) = self.lookup_constructor(aliased_name) {
+            return Some(def_id);
+        }
+
+        // Check qualified name mapping for the aliased name
+        if let Some(unqualified) = self.qualified_names.get(&aliased_name) {
             if let Some(def_id) = self.lookup_constructor(*unqualified) {
                 return Some(def_id);
             }
         }
 
-        // Try direct lookup of the qualified name
-        if let Some(def_id) = self.lookup_constructor(qualified_name) {
-            return Some(def_id);
+        // Then, check if the qualifier is an alias and try the full module name
+        if let Some(&module) = self.import_aliases.get(&qualifier) {
+            let qualified_name = Symbol::intern(&format!("{}.{}", module.as_str(), name.as_str()));
+
+            if let Some(unqualified) = self.qualified_names.get(&qualified_name) {
+                if let Some(def_id) = self.lookup_constructor(*unqualified) {
+                    return Some(def_id);
+                }
+            }
+
+            if let Some(def_id) = self.lookup_constructor(qualified_name) {
+                return Some(def_id);
+            }
         }
 
         // Try looking up the unqualified name directly (for builtins)