#include "HsVersions.h"
-import {-# SOURCE #-} DsExpr ( dsExpr, dsLet )
-
-import CmdLineOpts ( opt_WarnIncompletePatterns, opt_WarnOverlappingPatterns,
- opt_WarnSimplePatterns
- )
+import CmdLineOpts ( DynFlag(..), DynFlags, dopt )
import HsSyn
import TcHsSyn ( TypecheckedPat, TypecheckedMatch )
import DsHsSyn ( outPatType )
import DsGRHSs ( dsGRHSs )
import DsUtils
import Id ( idType, recordSelectorFieldLabel, Id )
-import DataCon ( dataConFieldLabels, dataConArgTys )
+import DataCon ( dataConFieldLabels, dataConInstOrigArgTys )
import MatchCon ( matchConFamily )
import MatchLit ( matchLiterals )
import PrelInfo ( pAT_ERROR_ID )
-import Type ( isUnLiftedType, splitAlgTyConApp,
- mkTyVarTys, Type
- )
-import TysPrim ( intPrimTy, charPrimTy, floatPrimTy, doublePrimTy,
- addrPrimTy, wordPrimTy
- )
-import TysWiredIn ( nilDataCon, consDataCon, mkTupleTy, mkListTy,
- charTy, charDataCon, intTy, intDataCon,
- floatTy, floatDataCon, doubleTy, tupleCon,
- doubleDataCon, addrTy,
- addrDataCon, wordTy, wordDataCon,
- mkUnboxedTupleTy, unboxedTupleCon
- )
+import Type ( splitAlgTyConApp, mkTyVarTys, Type )
+import TysWiredIn ( nilDataCon, consDataCon, mkTupleTy, mkListTy, tupleCon )
+import BasicTypes ( Boxity(..) )
import UniqSet
import ErrUtils ( addErrLocHdrLine, dontAddErrLoc )
import Outputable
-> [EquationInfo] -- Info about patterns, etc. (type synonym below)
-> DsM MatchResult -- Desugared result!
-matchExport vars qs@((EqnInfo _ ctx _ (MatchResult _ _)) : _)
+
+matchExport vars qs
+ = getDOptsDs `thenDs` \ dflags ->
+ matchExport_really dflags vars qs
+
+matchExport_really dflags vars qs@((EqnInfo _ ctx _ (MatchResult _ _)) : _)
| incomplete && shadow =
dsShadowWarn ctx eqns_shadow `thenDs` \ () ->
dsIncompleteWarn ctx pats `thenDs` \ () ->
| otherwise =
match vars qs
where (pats,indexs) = check qs
- incomplete = opt_WarnIncompletePatterns && (length pats /= 0)
- shadow = opt_WarnOverlappingPatterns && sizeUniqSet indexs < no_eqns
+ incomplete = dopt Opt_WarnIncompletePatterns dflags
+ && (length pats /= 0)
+ shadow = dopt Opt_WarnOverlappingPatterns dflags
+ && sizeUniqSet indexs < no_eqns
no_eqns = length qs
unused_eqns = uniqSetToList (mkUniqSet [1..no_eqns] `minusUniqSet` indexs)
eqns_shadow = map (\n -> qs!!(n - 1)) unused_eqns
-- Boring stuff to find the arg-tys of the constructor
(_, inst_tys, _) = splitAlgTyConApp pat_ty
- con_arg_tys' = dataConArgTys data_con (inst_tys ++ mkTyVarTys ex_tvs)
+ con_arg_tys' = dataConInstOrigArgTys data_con (inst_tys ++ mkTyVarTys ex_tvs)
tagged_arg_tys = con_arg_tys' `zip` (dataConFieldLabels data_con)
-- mk_pat picks a WildPat of the appropriate type for absent fields,
(ConPat nilDataCon list_ty [] [] [])
pats
-tidy1 v (TuplePat pats True{-boxed-}) match_result
- = returnDs (tuple_ConPat, match_result)
- where
- arity = length pats
- tuple_ConPat
- = ConPat (tupleCon arity)
- (mkTupleTy arity (map outPatType pats)) [] []
- pats
-
-tidy1 v (TuplePat pats False{-unboxed-}) match_result
+tidy1 v (TuplePat pats boxity) match_result
= returnDs (tuple_ConPat, match_result)
where
arity = length pats
tuple_ConPat
- = ConPat (unboxedTupleCon arity)
- (mkUnboxedTupleTy arity (map outPatType pats)) [] []
+ = ConPat (tupleCon boxity arity)
+ (mkTupleTy boxity arity (map outPatType pats)) [] []
pats
tidy1 v (DictPat dicts methods) match_result
= case num_of_d_and_ms of
- 0 -> tidy1 v (TuplePat [] True) match_result
+ 0 -> tidy1 v (TuplePat [] Boxed) match_result
1 -> tidy1 v (head dict_and_method_pats) match_result
- _ -> tidy1 v (TuplePat dict_and_method_pats True) match_result
+ _ -> tidy1 v (TuplePat dict_and_method_pats Boxed) match_result
where
num_of_d_and_ms = length dicts + length methods
dict_and_method_pats = map VarPat (dicts ++ methods)
-
--- deeply ugly mangling for some (common) NPats/LitPats
-
--- LitPats: the desugarer only sees these at well-known types
-
+-- LitPats: we *might* be able to replace these w/ a simpler form
tidy1 v pat@(LitPat lit lit_ty) match_result
- = returnDs (tidyLitPat lit lit_ty pat, match_result)
+ = returnDs (tidyLitPat lit pat, match_result)
-- NPats: we *might* be able to replace these w/ a simpler form
tidy1 v pat@(NPat lit lit_ty _) match_result
- = returnDs (tidyLitPat lit lit_ty pat, match_result)
+ = returnDs (tidyNPat lit lit_ty pat, match_result)
-- and everything else goes through unchanged...
\begin{code}
matchWrapper kind matches error_string
- = flattenMatches kind matches `thenDs` \ (result_ty, eqns_info) ->
+ = getDOptsDs `thenDs` \ dflags ->
+ flattenMatches kind matches `thenDs` \ (result_ty, eqns_info) ->
let
EqnInfo _ _ arg_pats _ : _ = eqns_info
in
- mapDs selectMatchVar arg_pats `thenDs` \ new_vars ->
- match_fun new_vars eqns_info `thenDs` \ match_result ->
+ mapDs selectMatchVar arg_pats `thenDs` \ new_vars ->
+ match_fun dflags new_vars eqns_info `thenDs` \ match_result ->
mkErrorAppDs pAT_ERROR_ID result_ty error_string `thenDs` \ fail_expr ->
extractMatchResult match_result fail_expr `thenDs` \ result_expr ->
returnDs (new_vars, result_expr)
- where match_fun = case kind of
- LambdaMatch | opt_WarnSimplePatterns -> matchExport
- | otherwise -> match
- _ -> matchExport
+ where match_fun dflags
+ = case kind of
+ LambdaMatch | dopt Opt_WarnSimplePatterns dflags -> matchExport
+ | otherwise -> match
+ _ -> matchExport
\end{code}
%************************************************************************
-> MatchResult -> DsM MatchResult
matchSinglePat (Var var) ctx pat match_result
- = match_fn [var] [EqnInfo 1 ctx [pat] match_result]
+ = getDOptsDs `thenDs` \ dflags ->
+ match_fn dflags [var] [EqnInfo 1 ctx [pat] match_result]
where
- match_fn | opt_WarnSimplePatterns = matchExport
- | otherwise = match
+ match_fn dflags
+ | dopt Opt_WarnSimplePatterns dflags = matchExport
+ | otherwise = match
matchSinglePat scrut ctx pat match_result
= selectMatchVar pat `thenDs` \ var ->
projects / ghc-hetmet.git / blobdiff