hssqlppp-0.2.0: Database/HsSqlPpp/AstInternals/AstInternal.hs
-- UUAGC 0.9.13 (AstInternal.ag)
module Database.HsSqlPpp.AstInternals.AstInternal(
-- {-# LANGUAGE DeriveDataTypeable,RankNTypes,ScopedTypeVariables #-}
-- {-# OPTIONS_HADDOCK hide #-}
--from the ag files:
--ast nodes
Statement (..)
,SelectExpression (..)
,FnBody (..)
,SetClause (..)
,TableRef (..)
,TableAlias(..)
,JoinExpression (..)
,JoinType (..)
,SelectList (..)
,SelectItem (..)
,CopySource (..)
,AttributeDef (..)
,RowConstraint (..)
,AlterTableAction(..)
,Constraint (..)
,TypeAttributeDef (..)
,ParamDef (..)
,VarDef (..)
,RaiseType (..)
,CombineType (..)
,Volatility (..)
,Language (..)
,TypeName (..)
,DropType (..)
,Cascade (..)
,Direction (..)
,Distinct (..)
,Natural (..)
,IfExists (..)
,RestartIdentity (..)
,Expression (..)
,FrameClause(..)
,InList (..)
,LiftFlavour(..)
,TriggerWhen(..)
,TriggerEvent(..)
,TriggerFire(..)
,StatementList
,ExpressionListStatementListPairList
,ExpressionListStatementListPair
,ExpressionList
,StringList
,ParamDefList
,AttributeDefList
,ConstraintList
,TypeAttributeDefList
,TypeNameList
,StringTypeNameListPair
,StringTypeNameListPairList
,ExpressionStatementListPairList
,SetClauseList
,CaseExpressionListExpressionPairList
,MaybeExpression
,TableRefList
,ExpressionListList
,SelectItemList
,OnExpr
,RowConstraintList
,VarDefList
,ExpressionStatementListPair
,CaseExpressionListExpressionPair
,CaseExpressionList
,ExpressionDirectionPair
,ExpressionDirectionPairList
,MaybeBoolExpression
,MaybeSelectList
,SetValue(..)
-- typechecking
,typeCheck
,typeCheckPS
,typeCheckExpression
) where
import Data.Maybe
import Data.List
import Debug.Trace
--import Control.Monad.Error
import Data.Either
import Control.Applicative
import Data.Generics
import Data.Char
import Control.Monad.State
import Database.HsSqlPpp.AstInternals.TypeType
import Database.HsSqlPpp.AstInternals.TypeChecking.TypeConversion
import Database.HsSqlPpp.AstInternals.TypeChecking.ErrorUtils
import Database.HsSqlPpp.AstInternals.AstAnnotation
import Database.HsSqlPpp.AstInternals.Catalog.CatalogInternal
import Database.HsSqlPpp.AstInternals.TypeChecking.LocalIdentifierBindings
--import Database.HsSqlPpp.AstInternals.Catalog.DefaultTemplate1Catalog
import Database.HsSqlPpp.Utils
import Data.Generics.PlateData
{-# LINE 683 "AstInternal.ag" #-}
{-
-- | Type check multiple asts, allowing type checking references in
-- later files to definitions in earlier files. This is probably
-- more straightforward if you parse the files then concatenate the
-- statementlists together before type checking rather than using
-- this function
typeCheckMany :: Catalog -> [StatementList] -> [StatementList]
typeCheckMany cat sts =
annInt cat sts []
where
annInt e (s:ss) ress =
let (e1,res) = typeCheck e s
in annInt e1 ss (res:ress)
annInt _ [] ress = reverse ress
-}
-- | Takes an ast, checks against catalog passed, and adds
-- annotations, including types, type errors, and statement info.
-- Returns the updated catalog as well as the annotated ast.
typeCheck :: Catalog -> StatementList -> (Catalog,StatementList)
typeCheck cat sts =
let t = sem_Root (Root (fixupImplicitJoins sts))
ta = wrap_Root t Inh_Root {cat_Inh_Root = cat
,lib_Inh_Root = emptyBindings}
tl = annotatedTree_Syn_Root ta
cat1 = producedCat_Syn_Root ta
in case tl of
Root r -> (cat1,r)
-- | Unfinished version of type check which can type check an
-- individual statement with ? or positional arg placeholders in
-- it. Will error if the statement isn't select, update, insert or
-- delete. For use in type checking embedded parameterized
-- statements. Does all typechecking and annotation that the regular
-- typecheck does.
typeCheckPS :: Catalog -> Statement -> Either String Statement
typeCheckPS cat st =
case st of
SelectStatement _ _ -> tc
Insert _ _ _ _ _ -> tc
Update _ _ _ _ _ -> tc
Delete _ _ _ _ -> tc
_ -> Left "requires select, update, insert or delete statement"
where
tc = let t = sem_Root (Root (fixupImplicitJoins [st]))
ta = wrap_Root t Inh_Root {cat_Inh_Root = cat
,lib_Inh_Root = emptyBindings}
tl = annotatedTree_Syn_Root ta
cat1 = producedCat_Syn_Root ta
in case tl of
Root [st1] -> Right st1
_ -> error "impossible happened in typeCheckPS!"
-- | Testing utility, mainly used to check an expression for type errors
-- or to get its type.
typeCheckExpression :: Catalog -> Expression -> Expression
typeCheckExpression cat ex =
let t = sem_ExpressionRoot (ExpressionRoot (fixupImplicitJoins ex))
rt = (annotatedTree_Syn_ExpressionRoot
(wrap_ExpressionRoot t Inh_ExpressionRoot {cat_Inh_ExpressionRoot = cat
,lib_Inh_ExpressionRoot = emptyBindings}))
in case rt of
ExpressionRoot e -> e
{-
bit of a hack, to avoid rewriting the tableref type checking to be
able to do implicit joins, we just convert them in to the equivalent
explicit join
-}
fixupImplicitJoins :: Data a => a -> a
fixupImplicitJoins =
transformBi $ \x ->
case x of
-- alter asts to change implicit joins into explicit joins
Select an dis sl trs@(_:_:_) whr grp hav ord lim off
-> Select an dis sl [convTrefs trs] whr grp hav ord lim off
x1 -> x1
where
convTrefs (tr:tr1:trs) = JoinedTref [] tr Unnatural Cross (convTrefs (tr1:trs)) Nothing NoAlias
convTrefs (tr:[]) = tr
convTrefs _ = error "failed doing implicit join fixup hack"
{-# LINE 190 "AstInternal.hs" #-}
{-# LINE 81 "./TypeChecking/Misc.ag" #-}
{-
================================================================================
= couple of small utils
I think this should be alright, an identifier referenced in an
expression can only have zero or one dot in it.
-}
splitIdentifier :: String -> (String,String)
splitIdentifier s = let (a,b) = span (/= '.') s
in if b == ""
then ("", a)
else (a,tail b)
{-
helper to make adding annotations a bit easier
-}
annTypesAndErrors :: Data a => a -> Type -> [TypeError]
-> Maybe [AnnotationElement] -> a
annTypesAndErrors item nt errs add =
updateAnnotation modifier item
where
modifier = (([TypeAnnotation nt] ++ fromMaybe [] add ++
map TypeErrorA errs) ++)
{-
================================================================================
proper dodgy:
1st pass is to add inferred types to the tree. This is done only for
expressions in a funcall argument list atm. Then we pull out the
placeholders after they've had this information added. Only the
placeholders in funcall argument lists will have their type inferred
in this way, to be expanded. Insert also does this currently, but in Dml.ag
This should probably be done during the typechecking phase instead,
but probably needs a proper type inferencing algorithm to be used, is
done like this for development expediency.
-}
getPlaceholders :: Data a => a -> [Expression]
getPlaceholders st =
filter isPlaceholder $ everything (++) (mkQ [] ga) (setInferredTypes st)
where
ga :: Expression -> [Expression]
ga s = [s]
isPlaceholder e = case e of
PositionalArg _ _ -> True
Placeholder _ -> True
_ -> False
getPlaceholderTypes :: Data a => a -> [Type]
getPlaceholderTypes ex =
map (getInferredType . getAnnotation) $ getPlaceholders ex
where
getInferredType (InferredType t:_) = t
getInferredType (_:as) = getInferredType as
getInferredType [] = TypeCheckFailed
setInferredTypes :: Data a => a -> a
setInferredTypes =
doExprs {-. doSts-}
where
doExprs =
transformBi (\x ->
case x of
FunCall an op exprs
-> FunCall an op (addInferredTypes an exprs)
x1 -> x1)
{-doSts =
transformBi (\x ->
case x of
Insert ann table targetCols insData returning
-> Insert ann table targetCols insData returning
x1 -> x1)-}
addInferredTypes an exprs =
let args1 = fmap (\(_,a,_,_) -> a) $ fp an
args = fromMaybe [] args1
fargs = args ++ repeat TypeCheckFailed
in flip map (zip exprs fargs)
(\(ex, ty) -> updateAnnotation (++ [InferredType ty]) ex)
where
fp (FunctionPrototypeA f:_) = Just f
fp (_:ls) = fp ls
fp [] = Nothing
{-# LINE 283 "AstInternal.hs" #-}
{-# LINE 94 "./TypeChecking/Expressions.ag" #-}
{-
small shim in front of findCallMatch in the type conversion code, to
handle some special cases.
Some of the special cases will no longer be needed when variadic
support is added.
between, greatest and least are treated as syntactic sugar so we
delegate the function lookups to the <=/>= operators.
the row comparison should be more general than this, since it supports
any operator satisfying some properties
TODO: move all of this into find call match. Don't know why it's separate
-}
typeCheckFunCall :: Catalog -> String -> [Type] -> Either [TypeError] FunctionPrototype
typeCheckFunCall cat fnName' argsType =
{-trace ("typecheckfncall " ++ fnName' ++ show argsType) $-}
--dependsOnRTpe argsType $
case fnName of
"count" -> -- not quite sure how this is suppose to work,
-- the counts in the pg catalog accept either
-- no args, or one arg of type any, but you can call
-- count with multiple arguments?
return ("count", argsType, typeBigInt, False)
"!between" -> do
f1 <- lookupReturnType ">=" [argsType !! 0, argsType !! 1]
f2 <- lookupReturnType "<=" [argsType !! 0, argsType !! 2]
lookupFn "!and" [f1,f2]
"greatest" -> do
fp@(_,_,t,_) <- lookupFn fnName argsType
lookupFn ">=" [t,t]
return fp
"least" -> do
fp@(_,_,t,_) <- lookupFn fnName argsType
lookupFn "<=" [t,t]
return fp
"!rowctor" -> return $ ("!rowCtor", argsType, AnonymousRecordType argsType, False)
-- special case the row comparison ops
-- this needs to be fixed: we want to match
-- any implicit casts to functions on composite types
-- first, then we can use the anonymous record type on
-- any composite
_ | fnName `elem` ["=", "<>", "<=", ">=", "<", ">"]
&& length argsType == 2
&& all isCompositeOrSetOfCompositeType argsType
&& compositesCompatible cat (head argsType) (head $ tail argsType) -> return (fnName, argsType, typeBool, False)
--checked for all special cases, so run general case now
s -> lookupFn s argsType
where
lookupReturnType :: String -> [Type] -> Either [TypeError] Type
lookupReturnType s1 args = fmap (\(_,_,r,_) -> r) $ lookupFn s1 args
lookupFn :: String -> [Type] -> Either [TypeError] FunctionPrototype
lookupFn s1 args = findCallMatch cat
(if s1 == "u-" then "-" else s1) args
fnName = map toLower fnName'
{-# LINE 345 "AstInternal.hs" #-}
{-# LINE 138 "./TypeChecking/SelectStatement.ag" #-}
typeCheckValuesExpr :: Catalog -> [[Type]] -> Either [TypeError] Type
typeCheckValuesExpr cat rowsTs =
let colNames = zipWith (++)
(repeat "column")
(map show [1..length $ head rowsTs])
in unionRelTypes cat rowsTs colNames
typeCheckCombineSelect :: Catalog -> Type -> Type -> Either [TypeError] Type
typeCheckCombineSelect cat v1 v2 = do
u1 <- unwrapSetOfComposite v1
let colNames = map fst u1
u2 <- unwrapSetOfComposite v2
let colTypes1 = map snd u1
let colTypes2 = map snd u2
unionRelTypes cat [colTypes1,colTypes2] colNames
unionRelTypes :: Catalog -> [[Type]] -> [String] -> Either [TypeError] Type
unionRelTypes cat rowsTs colNames =
let lengths = map length rowsTs
in case () of
_ | null rowsTs ->
Left [NoRowsGivenForValues]
| not (all (==head lengths) lengths) ->
Left [ValuesListsMustBeSameLength]
| otherwise ->
--i don't think this propagates all the errors, just the first set
mapM (resolveResultSetType cat) (transpose rowsTs) >>=
(return . SetOfType . CompositeType . zip colNames)
{-# LINE 380 "AstInternal.hs" #-}
{-# LINE 200 "./TypeChecking/TableRefs.ag" #-}
{-
convert a function call into a [String,[(string,type)]] list for use
in a tableref context
first consideration is the alias: if there is an alias in the select,
e.g. select * from generate_series(1,2) x; (alias is x)
we use that, otherwise we use the name of the function
second consideration is the attributes coming out, roughly speaking
we have to convert an arbitrary type to a relation type
if we have a relation valued function, we don't need to do anything
if we have a setof non composite, we lift the single type to an
attribute, using the function name for the attribute name
if we have a non setof, we lift the single type to an attribute and
then relation, using the function name for the attribute name
need to check to see what should happen with arrayof
-}
funIdens :: Catalog -> String -> Expression -> Either [TypeError] (String,[(String,Type)])
funIdens cat alias fnVal = do
errorWhen (case fnVal of
FunCall _ _ _ -> False
_ -> True)
[ContextError "FunCall"]
let (FunCall _ fnName _) = fnVal
correlationName = if alias /= ""
then alias
else fnName
attrs <- do
case getTypeAnnotation fnVal of
SetOfType (NamedCompositeType t) -> catCompositePublicAttrs cat [] t
SetOfType x -> return [(correlationName,x)]
y -> return [(correlationName,y)]
return (correlationName, attrs)
getAlias :: String -> TableAlias -> String
getAlias def alias =
case alias of
NoAlias -> def
TableAlias t -> t
FullAlias t _ -> t
{-# LINE 424 "AstInternal.hs" #-}
{-# LINE 92 "./TypeChecking/SelectLists.ag" #-}
expandStar :: LocalIdentifierBindings
-> String
-> Type
-> [(String,Type)]
-> [(String,Type)]
expandStar cat colName colType types =
fromRight types $ do
let (correlationName,iden) = splitIdentifier colName
newCols <- if iden == "*"
then libExpandStar cat correlationName
else return [(iden, colType)]
return $ newCols ++ types
fixStar :: Expression -> Expression
fixStar =
everywhere (mkT fixStar')
where
fixStar' :: Annotation -> Annotation
fixStar' a =
if TypeAnnotation TypeCheckFailed `elem` a
&& any (\an ->
case an of
TypeErrorA (UnrecognisedIdentifier x) |
let (_,iden) = splitIdentifier x
in iden == "*" -> True
_ -> False) a
then filter (\an -> case an of
TypeAnnotation TypeCheckFailed -> False
TypeErrorA (UnrecognisedIdentifier _) -> False
_ -> True) a
else a
{-# LINE 459 "AstInternal.hs" #-}
{-# LINE 96 "./TypeChecking/Dml.ag" #-}
setInferredTypesG :: Data a => [Type] -> a -> a
setInferredTypesG tys x =
evalState (transformBiM f x) tys
where
f (p@(Placeholder _)) = do
y:ys <- get
put ys
return $ updateAnnotation (++ [InferredType y]) p
f z = return z
{-# LINE 473 "AstInternal.hs" #-}
{-# LINE 163 "./TypeChecking/Dml.ag" #-}
getRowTypes :: [Type] -> [Type]
getRowTypes [AnonymousRecordType ts] = ts
getRowTypes ts = ts
{-# LINE 480 "AstInternal.hs" #-}
{-# LINE 202 "./TypeChecking/Dml.ag" #-}
--small shortcut to help produce better errors?
checkRelationExists :: Catalog -> String -> Either [TypeError] ()
checkRelationExists cat tbl =
catCompositeDef cat relationComposites tbl >>
return ()
--used by both insert and update
checkColumnConsistency :: Catalog -> String -> [String] -> [(String,Type)]
-> Either [TypeError] [(String,Type)]
checkColumnConsistency cat tbl cols' insNameTypePairs = do
ttcols <- lowerize <$> catCompositePublicAttrs cat [] tbl
let cols = if null cols'
then map fst ttcols
else map (map toLower) cols'
errorWhen (length insNameTypePairs /= length cols) [WrongNumberOfColumns]
let nonMatchingColumns = cols \\ map fst ttcols
errorWhen (not $ null nonMatchingColumns) $
map UnrecognisedIdentifier nonMatchingColumns
let targetNameTypePairs = map (\l -> (l,fromJust $ lookup l ttcols)) cols
--check the types of the insdata match the column targets
--name datatype columntype
typeTriples = map (\((a,b),c) -> (a,b,c)) $
zip targetNameTypePairs $
map snd insNameTypePairs
errs :: [TypeError]
errs = concat $ lefts $
map (\(_,b,c) -> checkAssignmentValid cat c b) typeTriples
liftErrors errs
return targetNameTypePairs
where
lowerize = map (\(a,b) -> (map toLower a,b))
{-# LINE 517 "AstInternal.hs" #-}
{-# LINE 40 "./TypeChecking/CreateTable.ag" #-}
defaultSystemColumns :: [(String,Type)]
defaultSystemColumns = [("tableoid", ScalarType "oid")
,("cmax", ScalarType "cid")
,("xmax", ScalarType "xid")
,("cmin", ScalarType "cid")
,("xmin", ScalarType "xid")
,("ctid", ScalarType "tid")]
{-# LINE 528 "AstInternal.hs" #-}
-- AlterTableAction --------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
originalTree : SELF
alternatives:
alternative AddConstraint:
child ann : {Annotation}
child con : Constraint
visit 0:
local annotatedTree : _
local originalTree : _
alternative AlterColumnDefault:
child ann : {Annotation}
child nm : {String}
child def : Expression
visit 0:
local annotatedTree : _
local originalTree : _
-}
data AlterTableAction = AddConstraint (Annotation) (Constraint)
| AlterColumnDefault (Annotation) (String) (Expression)
deriving ( Data,Eq,Show,Typeable)
-- cata
sem_AlterTableAction :: AlterTableAction ->
T_AlterTableAction
sem_AlterTableAction (AddConstraint _ann _con ) =
(sem_AlterTableAction_AddConstraint _ann (sem_Constraint _con ) )
sem_AlterTableAction (AlterColumnDefault _ann _nm _def ) =
(sem_AlterTableAction_AlterColumnDefault _ann _nm (sem_Expression _def ) )
-- semantic domain
type T_AlterTableAction = Catalog ->
LocalIdentifierBindings ->
( AlterTableAction,AlterTableAction)
data Inh_AlterTableAction = Inh_AlterTableAction {cat_Inh_AlterTableAction :: Catalog,lib_Inh_AlterTableAction :: LocalIdentifierBindings}
data Syn_AlterTableAction = Syn_AlterTableAction {annotatedTree_Syn_AlterTableAction :: AlterTableAction,originalTree_Syn_AlterTableAction :: AlterTableAction}
wrap_AlterTableAction :: T_AlterTableAction ->
Inh_AlterTableAction ->
Syn_AlterTableAction
wrap_AlterTableAction sem (Inh_AlterTableAction _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_AlterTableAction _lhsOannotatedTree _lhsOoriginalTree ))
sem_AlterTableAction_AddConstraint :: Annotation ->
T_Constraint ->
T_AlterTableAction
sem_AlterTableAction_AddConstraint ann_ con_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: AlterTableAction
_lhsOoriginalTree :: AlterTableAction
_conOcat :: Catalog
_conOlib :: LocalIdentifierBindings
_conIannotatedTree :: Constraint
_conIoriginalTree :: Constraint
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
AddConstraint ann_ _conIannotatedTree
{-# LINE 592 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
AddConstraint ann_ _conIoriginalTree
{-# LINE 597 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 602 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 607 "AstInternal.hs" #-}
-- copy rule (down)
_conOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 612 "AstInternal.hs" #-}
-- copy rule (down)
_conOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 617 "AstInternal.hs" #-}
( _conIannotatedTree,_conIoriginalTree) =
(con_ _conOcat _conOlib )
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
sem_AlterTableAction_AlterColumnDefault :: Annotation ->
String ->
T_Expression ->
T_AlterTableAction
sem_AlterTableAction_AlterColumnDefault ann_ nm_ def_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: AlterTableAction
_lhsOoriginalTree :: AlterTableAction
_defOcat :: Catalog
_defOlib :: LocalIdentifierBindings
_defIannotatedTree :: Expression
_defIliftedColumnName :: String
_defIoriginalTree :: Expression
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
AlterColumnDefault ann_ nm_ _defIannotatedTree
{-# LINE 639 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
AlterColumnDefault ann_ nm_ _defIoriginalTree
{-# LINE 644 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 649 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 654 "AstInternal.hs" #-}
-- copy rule (down)
_defOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 659 "AstInternal.hs" #-}
-- copy rule (down)
_defOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 664 "AstInternal.hs" #-}
( _defIannotatedTree,_defIliftedColumnName,_defIoriginalTree) =
(def_ _defOcat _defOlib )
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
-- AttributeDef ------------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
attrName : String
namedType : Type
originalTree : SELF
alternatives:
alternative AttributeDef:
child ann : {Annotation}
child name : {String}
child typ : TypeName
child def : MaybeExpression
child cons : RowConstraintList
visit 0:
local annotatedTree : _
local originalTree : _
-}
data AttributeDef = AttributeDef (Annotation) (String) (TypeName) (MaybeExpression) (RowConstraintList)
deriving ( Data,Eq,Show,Typeable)
-- cata
sem_AttributeDef :: AttributeDef ->
T_AttributeDef
sem_AttributeDef (AttributeDef _ann _name _typ _def _cons ) =
(sem_AttributeDef_AttributeDef _ann _name (sem_TypeName _typ ) (sem_MaybeExpression _def ) (sem_RowConstraintList _cons ) )
-- semantic domain
type T_AttributeDef = Catalog ->
LocalIdentifierBindings ->
( AttributeDef,String,Type,AttributeDef)
data Inh_AttributeDef = Inh_AttributeDef {cat_Inh_AttributeDef :: Catalog,lib_Inh_AttributeDef :: LocalIdentifierBindings}
data Syn_AttributeDef = Syn_AttributeDef {annotatedTree_Syn_AttributeDef :: AttributeDef,attrName_Syn_AttributeDef :: String,namedType_Syn_AttributeDef :: Type,originalTree_Syn_AttributeDef :: AttributeDef}
wrap_AttributeDef :: T_AttributeDef ->
Inh_AttributeDef ->
Syn_AttributeDef
wrap_AttributeDef sem (Inh_AttributeDef _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOattrName,_lhsOnamedType,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_AttributeDef _lhsOannotatedTree _lhsOattrName _lhsOnamedType _lhsOoriginalTree ))
sem_AttributeDef_AttributeDef :: Annotation ->
String ->
T_TypeName ->
T_MaybeExpression ->
T_RowConstraintList ->
T_AttributeDef
sem_AttributeDef_AttributeDef ann_ name_ typ_ def_ cons_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOattrName :: String
_lhsOnamedType :: Type
_consOlib :: LocalIdentifierBindings
_lhsOannotatedTree :: AttributeDef
_lhsOoriginalTree :: AttributeDef
_typOcat :: Catalog
_typOlib :: LocalIdentifierBindings
_defOcat :: Catalog
_defOlib :: LocalIdentifierBindings
_consOcat :: Catalog
_typIannotatedTree :: TypeName
_typInamedType :: Type
_typIoriginalTree :: TypeName
_defIannotatedTree :: MaybeExpression
_defIoriginalTree :: MaybeExpression
_consIannotatedTree :: RowConstraintList
_consIoriginalTree :: RowConstraintList
-- "./TypeChecking/CreateTable.ag"(line 79, column 9)
_lhsOattrName =
{-# LINE 79 "./TypeChecking/CreateTable.ag" #-}
map toLower name_
{-# LINE 740 "AstInternal.hs" #-}
-- "./TypeChecking/CreateTable.ag"(line 80, column 9)
_lhsOnamedType =
{-# LINE 80 "./TypeChecking/CreateTable.ag" #-}
_typInamedType
{-# LINE 745 "AstInternal.hs" #-}
-- "./TypeChecking/CreateTable.ag"(line 95, column 9)
_consOlib =
{-# LINE 95 "./TypeChecking/CreateTable.ag" #-}
case updateBindings _lhsIlib _lhsIcat
[LibStackIDs [("", [(name_, _typInamedType)])]] of
Left x -> error $ show x
Right e -> e
{-# LINE 753 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
AttributeDef ann_ name_ _typIannotatedTree _defIannotatedTree _consIannotatedTree
{-# LINE 758 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
AttributeDef ann_ name_ _typIoriginalTree _defIoriginalTree _consIoriginalTree
{-# LINE 763 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 768 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 773 "AstInternal.hs" #-}
-- copy rule (down)
_typOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 778 "AstInternal.hs" #-}
-- copy rule (down)
_typOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 783 "AstInternal.hs" #-}
-- copy rule (down)
_defOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 788 "AstInternal.hs" #-}
-- copy rule (down)
_defOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 793 "AstInternal.hs" #-}
-- copy rule (down)
_consOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 798 "AstInternal.hs" #-}
( _typIannotatedTree,_typInamedType,_typIoriginalTree) =
(typ_ _typOcat _typOlib )
( _defIannotatedTree,_defIoriginalTree) =
(def_ _defOcat _defOlib )
( _consIannotatedTree,_consIoriginalTree) =
(cons_ _consOcat _consOlib )
in ( _lhsOannotatedTree,_lhsOattrName,_lhsOnamedType,_lhsOoriginalTree)))
-- AttributeDefList --------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
attrs : [(String, Type)]
originalTree : SELF
alternatives:
alternative Cons:
child hd : AttributeDef
child tl : AttributeDefList
visit 0:
local annotatedTree : _
local originalTree : _
alternative Nil:
visit 0:
local annotatedTree : _
local originalTree : _
-}
type AttributeDefList = [(AttributeDef)]
-- cata
sem_AttributeDefList :: AttributeDefList ->
T_AttributeDefList
sem_AttributeDefList list =
(Prelude.foldr sem_AttributeDefList_Cons sem_AttributeDefList_Nil (Prelude.map sem_AttributeDef list) )
-- semantic domain
type T_AttributeDefList = Catalog ->
LocalIdentifierBindings ->
( AttributeDefList,([(String, Type)]),AttributeDefList)
data Inh_AttributeDefList = Inh_AttributeDefList {cat_Inh_AttributeDefList :: Catalog,lib_Inh_AttributeDefList :: LocalIdentifierBindings}
data Syn_AttributeDefList = Syn_AttributeDefList {annotatedTree_Syn_AttributeDefList :: AttributeDefList,attrs_Syn_AttributeDefList :: [(String, Type)],originalTree_Syn_AttributeDefList :: AttributeDefList}
wrap_AttributeDefList :: T_AttributeDefList ->
Inh_AttributeDefList ->
Syn_AttributeDefList
wrap_AttributeDefList sem (Inh_AttributeDefList _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOattrs,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_AttributeDefList _lhsOannotatedTree _lhsOattrs _lhsOoriginalTree ))
sem_AttributeDefList_Cons :: T_AttributeDef ->
T_AttributeDefList ->
T_AttributeDefList
sem_AttributeDefList_Cons hd_ tl_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOattrs :: ([(String, Type)])
_lhsOannotatedTree :: AttributeDefList
_lhsOoriginalTree :: AttributeDefList
_hdOcat :: Catalog
_hdOlib :: LocalIdentifierBindings
_tlOcat :: Catalog
_tlOlib :: LocalIdentifierBindings
_hdIannotatedTree :: AttributeDef
_hdIattrName :: String
_hdInamedType :: Type
_hdIoriginalTree :: AttributeDef
_tlIannotatedTree :: AttributeDefList
_tlIattrs :: ([(String, Type)])
_tlIoriginalTree :: AttributeDefList
-- "./TypeChecking/CreateTable.ag"(line 85, column 12)
_lhsOattrs =
{-# LINE 85 "./TypeChecking/CreateTable.ag" #-}
(_hdIattrName, _hdInamedType) : _tlIattrs
{-# LINE 871 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
(:) _hdIannotatedTree _tlIannotatedTree
{-# LINE 876 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
(:) _hdIoriginalTree _tlIoriginalTree
{-# LINE 881 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 886 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 891 "AstInternal.hs" #-}
-- copy rule (down)
_hdOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 896 "AstInternal.hs" #-}
-- copy rule (down)
_hdOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 901 "AstInternal.hs" #-}
-- copy rule (down)
_tlOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 906 "AstInternal.hs" #-}
-- copy rule (down)
_tlOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 911 "AstInternal.hs" #-}
( _hdIannotatedTree,_hdIattrName,_hdInamedType,_hdIoriginalTree) =
(hd_ _hdOcat _hdOlib )
( _tlIannotatedTree,_tlIattrs,_tlIoriginalTree) =
(tl_ _tlOcat _tlOlib )
in ( _lhsOannotatedTree,_lhsOattrs,_lhsOoriginalTree)))
sem_AttributeDefList_Nil :: T_AttributeDefList
sem_AttributeDefList_Nil =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOattrs :: ([(String, Type)])
_lhsOannotatedTree :: AttributeDefList
_lhsOoriginalTree :: AttributeDefList
-- "./TypeChecking/CreateTable.ag"(line 86, column 11)
_lhsOattrs =
{-# LINE 86 "./TypeChecking/CreateTable.ag" #-}
[]
{-# LINE 928 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
[]
{-# LINE 933 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
[]
{-# LINE 938 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 943 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 948 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOattrs,_lhsOoriginalTree)))
-- Cascade -----------------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
originalTree : SELF
alternatives:
alternative Cascade:
visit 0:
local annotatedTree : _
local originalTree : _
alternative Restrict:
visit 0:
local annotatedTree : _
local originalTree : _
-}
data Cascade = Cascade
| Restrict
deriving ( Data,Eq,Show,Typeable)
-- cata
sem_Cascade :: Cascade ->
T_Cascade
sem_Cascade (Cascade ) =
(sem_Cascade_Cascade )
sem_Cascade (Restrict ) =
(sem_Cascade_Restrict )
-- semantic domain
type T_Cascade = Catalog ->
LocalIdentifierBindings ->
( Cascade,Cascade)
data Inh_Cascade = Inh_Cascade {cat_Inh_Cascade :: Catalog,lib_Inh_Cascade :: LocalIdentifierBindings}
data Syn_Cascade = Syn_Cascade {annotatedTree_Syn_Cascade :: Cascade,originalTree_Syn_Cascade :: Cascade}
wrap_Cascade :: T_Cascade ->
Inh_Cascade ->
Syn_Cascade
wrap_Cascade sem (Inh_Cascade _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_Cascade _lhsOannotatedTree _lhsOoriginalTree ))
sem_Cascade_Cascade :: T_Cascade
sem_Cascade_Cascade =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: Cascade
_lhsOoriginalTree :: Cascade
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
Cascade
{-# LINE 1002 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
Cascade
{-# LINE 1007 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 1012 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 1017 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
sem_Cascade_Restrict :: T_Cascade
sem_Cascade_Restrict =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: Cascade
_lhsOoriginalTree :: Cascade
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
Restrict
{-# LINE 1029 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
Restrict
{-# LINE 1034 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 1039 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 1044 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
-- CaseExpressionList ------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
originalTree : SELF
alternatives:
alternative Cons:
child hd : Expression
child tl : CaseExpressionList
visit 0:
local annotatedTree : _
local originalTree : _
alternative Nil:
visit 0:
local annotatedTree : _
local originalTree : _
-}
type CaseExpressionList = [(Expression)]
-- cata
sem_CaseExpressionList :: CaseExpressionList ->
T_CaseExpressionList
sem_CaseExpressionList list =
(Prelude.foldr sem_CaseExpressionList_Cons sem_CaseExpressionList_Nil (Prelude.map sem_Expression list) )
-- semantic domain
type T_CaseExpressionList = Catalog ->
LocalIdentifierBindings ->
( CaseExpressionList,CaseExpressionList)
data Inh_CaseExpressionList = Inh_CaseExpressionList {cat_Inh_CaseExpressionList :: Catalog,lib_Inh_CaseExpressionList :: LocalIdentifierBindings}
data Syn_CaseExpressionList = Syn_CaseExpressionList {annotatedTree_Syn_CaseExpressionList :: CaseExpressionList,originalTree_Syn_CaseExpressionList :: CaseExpressionList}
wrap_CaseExpressionList :: T_CaseExpressionList ->
Inh_CaseExpressionList ->
Syn_CaseExpressionList
wrap_CaseExpressionList sem (Inh_CaseExpressionList _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_CaseExpressionList _lhsOannotatedTree _lhsOoriginalTree ))
sem_CaseExpressionList_Cons :: T_Expression ->
T_CaseExpressionList ->
T_CaseExpressionList
sem_CaseExpressionList_Cons hd_ tl_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: CaseExpressionList
_lhsOoriginalTree :: CaseExpressionList
_hdOcat :: Catalog
_hdOlib :: LocalIdentifierBindings
_tlOcat :: Catalog
_tlOlib :: LocalIdentifierBindings
_hdIannotatedTree :: Expression
_hdIliftedColumnName :: String
_hdIoriginalTree :: Expression
_tlIannotatedTree :: CaseExpressionList
_tlIoriginalTree :: CaseExpressionList
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
(:) _hdIannotatedTree _tlIannotatedTree
{-# LINE 1107 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
(:) _hdIoriginalTree _tlIoriginalTree
{-# LINE 1112 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 1117 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 1122 "AstInternal.hs" #-}
-- copy rule (down)
_hdOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 1127 "AstInternal.hs" #-}
-- copy rule (down)
_hdOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 1132 "AstInternal.hs" #-}
-- copy rule (down)
_tlOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 1137 "AstInternal.hs" #-}
-- copy rule (down)
_tlOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 1142 "AstInternal.hs" #-}
( _hdIannotatedTree,_hdIliftedColumnName,_hdIoriginalTree) =
(hd_ _hdOcat _hdOlib )
( _tlIannotatedTree,_tlIoriginalTree) =
(tl_ _tlOcat _tlOlib )
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
sem_CaseExpressionList_Nil :: T_CaseExpressionList
sem_CaseExpressionList_Nil =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: CaseExpressionList
_lhsOoriginalTree :: CaseExpressionList
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
[]
{-# LINE 1158 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
[]
{-# LINE 1163 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 1168 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 1173 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
-- CaseExpressionListExpressionPair ----------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
originalTree : SELF
alternatives:
alternative Tuple:
child x1 : CaseExpressionList
child x2 : Expression
visit 0:
local annotatedTree : _
local originalTree : _
-}
type CaseExpressionListExpressionPair = ( (CaseExpressionList),(Expression))
-- cata
sem_CaseExpressionListExpressionPair :: CaseExpressionListExpressionPair ->
T_CaseExpressionListExpressionPair
sem_CaseExpressionListExpressionPair ( x1,x2) =
(sem_CaseExpressionListExpressionPair_Tuple (sem_CaseExpressionList x1 ) (sem_Expression x2 ) )
-- semantic domain
type T_CaseExpressionListExpressionPair = Catalog ->
LocalIdentifierBindings ->
( CaseExpressionListExpressionPair,CaseExpressionListExpressionPair)
data Inh_CaseExpressionListExpressionPair = Inh_CaseExpressionListExpressionPair {cat_Inh_CaseExpressionListExpressionPair :: Catalog,lib_Inh_CaseExpressionListExpressionPair :: LocalIdentifierBindings}
data Syn_CaseExpressionListExpressionPair = Syn_CaseExpressionListExpressionPair {annotatedTree_Syn_CaseExpressionListExpressionPair :: CaseExpressionListExpressionPair,originalTree_Syn_CaseExpressionListExpressionPair :: CaseExpressionListExpressionPair}
wrap_CaseExpressionListExpressionPair :: T_CaseExpressionListExpressionPair ->
Inh_CaseExpressionListExpressionPair ->
Syn_CaseExpressionListExpressionPair
wrap_CaseExpressionListExpressionPair sem (Inh_CaseExpressionListExpressionPair _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_CaseExpressionListExpressionPair _lhsOannotatedTree _lhsOoriginalTree ))
sem_CaseExpressionListExpressionPair_Tuple :: T_CaseExpressionList ->
T_Expression ->
T_CaseExpressionListExpressionPair
sem_CaseExpressionListExpressionPair_Tuple x1_ x2_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: CaseExpressionListExpressionPair
_lhsOoriginalTree :: CaseExpressionListExpressionPair
_x1Ocat :: Catalog
_x1Olib :: LocalIdentifierBindings
_x2Ocat :: Catalog
_x2Olib :: LocalIdentifierBindings
_x1IannotatedTree :: CaseExpressionList
_x1IoriginalTree :: CaseExpressionList
_x2IannotatedTree :: Expression
_x2IliftedColumnName :: String
_x2IoriginalTree :: Expression
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
(_x1IannotatedTree,_x2IannotatedTree)
{-# LINE 1232 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
(_x1IoriginalTree,_x2IoriginalTree)
{-# LINE 1237 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 1242 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 1247 "AstInternal.hs" #-}
-- copy rule (down)
_x1Ocat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 1252 "AstInternal.hs" #-}
-- copy rule (down)
_x1Olib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 1257 "AstInternal.hs" #-}
-- copy rule (down)
_x2Ocat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 1262 "AstInternal.hs" #-}
-- copy rule (down)
_x2Olib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 1267 "AstInternal.hs" #-}
( _x1IannotatedTree,_x1IoriginalTree) =
(x1_ _x1Ocat _x1Olib )
( _x2IannotatedTree,_x2IliftedColumnName,_x2IoriginalTree) =
(x2_ _x2Ocat _x2Olib )
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
-- CaseExpressionListExpressionPairList ------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
originalTree : SELF
alternatives:
alternative Cons:
child hd : CaseExpressionListExpressionPair
child tl : CaseExpressionListExpressionPairList
visit 0:
local annotatedTree : _
local originalTree : _
alternative Nil:
visit 0:
local annotatedTree : _
local originalTree : _
-}
type CaseExpressionListExpressionPairList = [(CaseExpressionListExpressionPair)]
-- cata
sem_CaseExpressionListExpressionPairList :: CaseExpressionListExpressionPairList ->
T_CaseExpressionListExpressionPairList
sem_CaseExpressionListExpressionPairList list =
(Prelude.foldr sem_CaseExpressionListExpressionPairList_Cons sem_CaseExpressionListExpressionPairList_Nil (Prelude.map sem_CaseExpressionListExpressionPair list) )
-- semantic domain
type T_CaseExpressionListExpressionPairList = Catalog ->
LocalIdentifierBindings ->
( CaseExpressionListExpressionPairList,CaseExpressionListExpressionPairList)
data Inh_CaseExpressionListExpressionPairList = Inh_CaseExpressionListExpressionPairList {cat_Inh_CaseExpressionListExpressionPairList :: Catalog,lib_Inh_CaseExpressionListExpressionPairList :: LocalIdentifierBindings}
data Syn_CaseExpressionListExpressionPairList = Syn_CaseExpressionListExpressionPairList {annotatedTree_Syn_CaseExpressionListExpressionPairList :: CaseExpressionListExpressionPairList,originalTree_Syn_CaseExpressionListExpressionPairList :: CaseExpressionListExpressionPairList}
wrap_CaseExpressionListExpressionPairList :: T_CaseExpressionListExpressionPairList ->
Inh_CaseExpressionListExpressionPairList ->
Syn_CaseExpressionListExpressionPairList
wrap_CaseExpressionListExpressionPairList sem (Inh_CaseExpressionListExpressionPairList _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_CaseExpressionListExpressionPairList _lhsOannotatedTree _lhsOoriginalTree ))
sem_CaseExpressionListExpressionPairList_Cons :: T_CaseExpressionListExpressionPair ->
T_CaseExpressionListExpressionPairList ->
T_CaseExpressionListExpressionPairList
sem_CaseExpressionListExpressionPairList_Cons hd_ tl_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: CaseExpressionListExpressionPairList
_lhsOoriginalTree :: CaseExpressionListExpressionPairList
_hdOcat :: Catalog
_hdOlib :: LocalIdentifierBindings
_tlOcat :: Catalog
_tlOlib :: LocalIdentifierBindings
_hdIannotatedTree :: CaseExpressionListExpressionPair
_hdIoriginalTree :: CaseExpressionListExpressionPair
_tlIannotatedTree :: CaseExpressionListExpressionPairList
_tlIoriginalTree :: CaseExpressionListExpressionPairList
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
(:) _hdIannotatedTree _tlIannotatedTree
{-# LINE 1333 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
(:) _hdIoriginalTree _tlIoriginalTree
{-# LINE 1338 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 1343 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 1348 "AstInternal.hs" #-}
-- copy rule (down)
_hdOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 1353 "AstInternal.hs" #-}
-- copy rule (down)
_hdOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 1358 "AstInternal.hs" #-}
-- copy rule (down)
_tlOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 1363 "AstInternal.hs" #-}
-- copy rule (down)
_tlOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 1368 "AstInternal.hs" #-}
( _hdIannotatedTree,_hdIoriginalTree) =
(hd_ _hdOcat _hdOlib )
( _tlIannotatedTree,_tlIoriginalTree) =
(tl_ _tlOcat _tlOlib )
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
sem_CaseExpressionListExpressionPairList_Nil :: T_CaseExpressionListExpressionPairList
sem_CaseExpressionListExpressionPairList_Nil =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: CaseExpressionListExpressionPairList
_lhsOoriginalTree :: CaseExpressionListExpressionPairList
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
[]
{-# LINE 1384 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
[]
{-# LINE 1389 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 1394 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 1399 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
-- CombineType -------------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
originalTree : SELF
alternatives:
alternative Except:
visit 0:
local annotatedTree : _
local originalTree : _
alternative Intersect:
visit 0:
local annotatedTree : _
local originalTree : _
alternative Union:
visit 0:
local annotatedTree : _
local originalTree : _
alternative UnionAll:
visit 0:
local annotatedTree : _
local originalTree : _
-}
data CombineType = Except
| Intersect
| Union
| UnionAll
deriving ( Data,Eq,Show,Typeable)
-- cata
sem_CombineType :: CombineType ->
T_CombineType
sem_CombineType (Except ) =
(sem_CombineType_Except )
sem_CombineType (Intersect ) =
(sem_CombineType_Intersect )
sem_CombineType (Union ) =
(sem_CombineType_Union )
sem_CombineType (UnionAll ) =
(sem_CombineType_UnionAll )
-- semantic domain
type T_CombineType = Catalog ->
LocalIdentifierBindings ->
( CombineType,CombineType)
data Inh_CombineType = Inh_CombineType {cat_Inh_CombineType :: Catalog,lib_Inh_CombineType :: LocalIdentifierBindings}
data Syn_CombineType = Syn_CombineType {annotatedTree_Syn_CombineType :: CombineType,originalTree_Syn_CombineType :: CombineType}
wrap_CombineType :: T_CombineType ->
Inh_CombineType ->
Syn_CombineType
wrap_CombineType sem (Inh_CombineType _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_CombineType _lhsOannotatedTree _lhsOoriginalTree ))
sem_CombineType_Except :: T_CombineType
sem_CombineType_Except =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: CombineType
_lhsOoriginalTree :: CombineType
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
Except
{-# LINE 1467 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
Except
{-# LINE 1472 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 1477 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 1482 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
sem_CombineType_Intersect :: T_CombineType
sem_CombineType_Intersect =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: CombineType
_lhsOoriginalTree :: CombineType
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
Intersect
{-# LINE 1494 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
Intersect
{-# LINE 1499 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 1504 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 1509 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
sem_CombineType_Union :: T_CombineType
sem_CombineType_Union =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: CombineType
_lhsOoriginalTree :: CombineType
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
Union
{-# LINE 1521 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
Union
{-# LINE 1526 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 1531 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 1536 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
sem_CombineType_UnionAll :: T_CombineType
sem_CombineType_UnionAll =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: CombineType
_lhsOoriginalTree :: CombineType
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
UnionAll
{-# LINE 1548 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
UnionAll
{-# LINE 1553 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 1558 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 1563 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
-- Constraint --------------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
originalTree : SELF
alternatives:
alternative CheckConstraint:
child ann : {Annotation}
child name : {String}
child expression : Expression
visit 0:
local annotatedTree : _
local originalTree : _
alternative PrimaryKeyConstraint:
child ann : {Annotation}
child name : {String}
child stringList : StringList
visit 0:
local annotatedTree : _
local originalTree : _
alternative ReferenceConstraint:
child ann : {Annotation}
child name : {String}
child atts : StringList
child table : {String}
child tableAtts : StringList
child onUpdate : Cascade
child onDelete : Cascade
visit 0:
local annotatedTree : _
local originalTree : _
alternative UniqueConstraint:
child ann : {Annotation}
child name : {String}
child stringList : StringList
visit 0:
local annotatedTree : _
local originalTree : _
-}
data Constraint = CheckConstraint (Annotation) (String) (Expression)
| PrimaryKeyConstraint (Annotation) (String) (StringList)
| ReferenceConstraint (Annotation) (String) (StringList) (String) (StringList) (Cascade) (Cascade)
| UniqueConstraint (Annotation) (String) (StringList)
deriving ( Data,Eq,Show,Typeable)
-- cata
sem_Constraint :: Constraint ->
T_Constraint
sem_Constraint (CheckConstraint _ann _name _expression ) =
(sem_Constraint_CheckConstraint _ann _name (sem_Expression _expression ) )
sem_Constraint (PrimaryKeyConstraint _ann _name _stringList ) =
(sem_Constraint_PrimaryKeyConstraint _ann _name (sem_StringList _stringList ) )
sem_Constraint (ReferenceConstraint _ann _name _atts _table _tableAtts _onUpdate _onDelete ) =
(sem_Constraint_ReferenceConstraint _ann _name (sem_StringList _atts ) _table (sem_StringList _tableAtts ) (sem_Cascade _onUpdate ) (sem_Cascade _onDelete ) )
sem_Constraint (UniqueConstraint _ann _name _stringList ) =
(sem_Constraint_UniqueConstraint _ann _name (sem_StringList _stringList ) )
-- semantic domain
type T_Constraint = Catalog ->
LocalIdentifierBindings ->
( Constraint,Constraint)
data Inh_Constraint = Inh_Constraint {cat_Inh_Constraint :: Catalog,lib_Inh_Constraint :: LocalIdentifierBindings}
data Syn_Constraint = Syn_Constraint {annotatedTree_Syn_Constraint :: Constraint,originalTree_Syn_Constraint :: Constraint}
wrap_Constraint :: T_Constraint ->
Inh_Constraint ->
Syn_Constraint
wrap_Constraint sem (Inh_Constraint _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_Constraint _lhsOannotatedTree _lhsOoriginalTree ))
sem_Constraint_CheckConstraint :: Annotation ->
String ->
T_Expression ->
T_Constraint
sem_Constraint_CheckConstraint ann_ name_ expression_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: Constraint
_lhsOoriginalTree :: Constraint
_expressionOcat :: Catalog
_expressionOlib :: LocalIdentifierBindings
_expressionIannotatedTree :: Expression
_expressionIliftedColumnName :: String
_expressionIoriginalTree :: Expression
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
CheckConstraint ann_ name_ _expressionIannotatedTree
{-# LINE 1655 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
CheckConstraint ann_ name_ _expressionIoriginalTree
{-# LINE 1660 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 1665 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 1670 "AstInternal.hs" #-}
-- copy rule (down)
_expressionOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 1675 "AstInternal.hs" #-}
-- copy rule (down)
_expressionOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 1680 "AstInternal.hs" #-}
( _expressionIannotatedTree,_expressionIliftedColumnName,_expressionIoriginalTree) =
(expression_ _expressionOcat _expressionOlib )
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
sem_Constraint_PrimaryKeyConstraint :: Annotation ->
String ->
T_StringList ->
T_Constraint
sem_Constraint_PrimaryKeyConstraint ann_ name_ stringList_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: Constraint
_lhsOoriginalTree :: Constraint
_stringListOcat :: Catalog
_stringListOlib :: LocalIdentifierBindings
_stringListIannotatedTree :: StringList
_stringListIoriginalTree :: StringList
_stringListIstrings :: ([String])
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
PrimaryKeyConstraint ann_ name_ _stringListIannotatedTree
{-# LINE 1702 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
PrimaryKeyConstraint ann_ name_ _stringListIoriginalTree
{-# LINE 1707 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 1712 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 1717 "AstInternal.hs" #-}
-- copy rule (down)
_stringListOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 1722 "AstInternal.hs" #-}
-- copy rule (down)
_stringListOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 1727 "AstInternal.hs" #-}
( _stringListIannotatedTree,_stringListIoriginalTree,_stringListIstrings) =
(stringList_ _stringListOcat _stringListOlib )
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
sem_Constraint_ReferenceConstraint :: Annotation ->
String ->
T_StringList ->
String ->
T_StringList ->
T_Cascade ->
T_Cascade ->
T_Constraint
sem_Constraint_ReferenceConstraint ann_ name_ atts_ table_ tableAtts_ onUpdate_ onDelete_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: Constraint
_lhsOoriginalTree :: Constraint
_attsOcat :: Catalog
_attsOlib :: LocalIdentifierBindings
_tableAttsOcat :: Catalog
_tableAttsOlib :: LocalIdentifierBindings
_onUpdateOcat :: Catalog
_onUpdateOlib :: LocalIdentifierBindings
_onDeleteOcat :: Catalog
_onDeleteOlib :: LocalIdentifierBindings
_attsIannotatedTree :: StringList
_attsIoriginalTree :: StringList
_attsIstrings :: ([String])
_tableAttsIannotatedTree :: StringList
_tableAttsIoriginalTree :: StringList
_tableAttsIstrings :: ([String])
_onUpdateIannotatedTree :: Cascade
_onUpdateIoriginalTree :: Cascade
_onDeleteIannotatedTree :: Cascade
_onDeleteIoriginalTree :: Cascade
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
ReferenceConstraint ann_ name_ _attsIannotatedTree table_ _tableAttsIannotatedTree _onUpdateIannotatedTree _onDeleteIannotatedTree
{-# LINE 1766 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
ReferenceConstraint ann_ name_ _attsIoriginalTree table_ _tableAttsIoriginalTree _onUpdateIoriginalTree _onDeleteIoriginalTree
{-# LINE 1771 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 1776 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 1781 "AstInternal.hs" #-}
-- copy rule (down)
_attsOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 1786 "AstInternal.hs" #-}
-- copy rule (down)
_attsOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 1791 "AstInternal.hs" #-}
-- copy rule (down)
_tableAttsOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 1796 "AstInternal.hs" #-}
-- copy rule (down)
_tableAttsOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 1801 "AstInternal.hs" #-}
-- copy rule (down)
_onUpdateOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 1806 "AstInternal.hs" #-}
-- copy rule (down)
_onUpdateOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 1811 "AstInternal.hs" #-}
-- copy rule (down)
_onDeleteOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 1816 "AstInternal.hs" #-}
-- copy rule (down)
_onDeleteOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 1821 "AstInternal.hs" #-}
( _attsIannotatedTree,_attsIoriginalTree,_attsIstrings) =
(atts_ _attsOcat _attsOlib )
( _tableAttsIannotatedTree,_tableAttsIoriginalTree,_tableAttsIstrings) =
(tableAtts_ _tableAttsOcat _tableAttsOlib )
( _onUpdateIannotatedTree,_onUpdateIoriginalTree) =
(onUpdate_ _onUpdateOcat _onUpdateOlib )
( _onDeleteIannotatedTree,_onDeleteIoriginalTree) =
(onDelete_ _onDeleteOcat _onDeleteOlib )
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
sem_Constraint_UniqueConstraint :: Annotation ->
String ->
T_StringList ->
T_Constraint
sem_Constraint_UniqueConstraint ann_ name_ stringList_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: Constraint
_lhsOoriginalTree :: Constraint
_stringListOcat :: Catalog
_stringListOlib :: LocalIdentifierBindings
_stringListIannotatedTree :: StringList
_stringListIoriginalTree :: StringList
_stringListIstrings :: ([String])
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
UniqueConstraint ann_ name_ _stringListIannotatedTree
{-# LINE 1849 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
UniqueConstraint ann_ name_ _stringListIoriginalTree
{-# LINE 1854 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 1859 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 1864 "AstInternal.hs" #-}
-- copy rule (down)
_stringListOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 1869 "AstInternal.hs" #-}
-- copy rule (down)
_stringListOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 1874 "AstInternal.hs" #-}
( _stringListIannotatedTree,_stringListIoriginalTree,_stringListIstrings) =
(stringList_ _stringListOcat _stringListOlib )
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
-- ConstraintList ----------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
originalTree : SELF
alternatives:
alternative Cons:
child hd : Constraint
child tl : ConstraintList
visit 0:
local annotatedTree : _
local originalTree : _
alternative Nil:
visit 0:
local annotatedTree : _
local originalTree : _
-}
type ConstraintList = [(Constraint)]
-- cata
sem_ConstraintList :: ConstraintList ->
T_ConstraintList
sem_ConstraintList list =
(Prelude.foldr sem_ConstraintList_Cons sem_ConstraintList_Nil (Prelude.map sem_Constraint list) )
-- semantic domain
type T_ConstraintList = Catalog ->
LocalIdentifierBindings ->
( ConstraintList,ConstraintList)
data Inh_ConstraintList = Inh_ConstraintList {cat_Inh_ConstraintList :: Catalog,lib_Inh_ConstraintList :: LocalIdentifierBindings}
data Syn_ConstraintList = Syn_ConstraintList {annotatedTree_Syn_ConstraintList :: ConstraintList,originalTree_Syn_ConstraintList :: ConstraintList}
wrap_ConstraintList :: T_ConstraintList ->
Inh_ConstraintList ->
Syn_ConstraintList
wrap_ConstraintList sem (Inh_ConstraintList _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_ConstraintList _lhsOannotatedTree _lhsOoriginalTree ))
sem_ConstraintList_Cons :: T_Constraint ->
T_ConstraintList ->
T_ConstraintList
sem_ConstraintList_Cons hd_ tl_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: ConstraintList
_lhsOoriginalTree :: ConstraintList
_hdOcat :: Catalog
_hdOlib :: LocalIdentifierBindings
_tlOcat :: Catalog
_tlOlib :: LocalIdentifierBindings
_hdIannotatedTree :: Constraint
_hdIoriginalTree :: Constraint
_tlIannotatedTree :: ConstraintList
_tlIoriginalTree :: ConstraintList
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
(:) _hdIannotatedTree _tlIannotatedTree
{-# LINE 1938 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
(:) _hdIoriginalTree _tlIoriginalTree
{-# LINE 1943 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 1948 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 1953 "AstInternal.hs" #-}
-- copy rule (down)
_hdOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 1958 "AstInternal.hs" #-}
-- copy rule (down)
_hdOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 1963 "AstInternal.hs" #-}
-- copy rule (down)
_tlOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 1968 "AstInternal.hs" #-}
-- copy rule (down)
_tlOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 1973 "AstInternal.hs" #-}
( _hdIannotatedTree,_hdIoriginalTree) =
(hd_ _hdOcat _hdOlib )
( _tlIannotatedTree,_tlIoriginalTree) =
(tl_ _tlOcat _tlOlib )
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
sem_ConstraintList_Nil :: T_ConstraintList
sem_ConstraintList_Nil =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: ConstraintList
_lhsOoriginalTree :: ConstraintList
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
[]
{-# LINE 1989 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
[]
{-# LINE 1994 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 1999 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 2004 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
-- CopySource --------------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
originalTree : SELF
alternatives:
alternative CopyFilename:
child string : {String}
visit 0:
local annotatedTree : _
local originalTree : _
alternative Stdin:
visit 0:
local annotatedTree : _
local originalTree : _
-}
data CopySource = CopyFilename (String)
| Stdin
deriving ( Data,Eq,Show,Typeable)
-- cata
sem_CopySource :: CopySource ->
T_CopySource
sem_CopySource (CopyFilename _string ) =
(sem_CopySource_CopyFilename _string )
sem_CopySource (Stdin ) =
(sem_CopySource_Stdin )
-- semantic domain
type T_CopySource = Catalog ->
LocalIdentifierBindings ->
( CopySource,CopySource)
data Inh_CopySource = Inh_CopySource {cat_Inh_CopySource :: Catalog,lib_Inh_CopySource :: LocalIdentifierBindings}
data Syn_CopySource = Syn_CopySource {annotatedTree_Syn_CopySource :: CopySource,originalTree_Syn_CopySource :: CopySource}
wrap_CopySource :: T_CopySource ->
Inh_CopySource ->
Syn_CopySource
wrap_CopySource sem (Inh_CopySource _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_CopySource _lhsOannotatedTree _lhsOoriginalTree ))
sem_CopySource_CopyFilename :: String ->
T_CopySource
sem_CopySource_CopyFilename string_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: CopySource
_lhsOoriginalTree :: CopySource
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
CopyFilename string_
{-# LINE 2060 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
CopyFilename string_
{-# LINE 2065 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 2070 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 2075 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
sem_CopySource_Stdin :: T_CopySource
sem_CopySource_Stdin =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: CopySource
_lhsOoriginalTree :: CopySource
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
Stdin
{-# LINE 2087 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
Stdin
{-# LINE 2092 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 2097 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 2102 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
-- Direction ---------------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
originalTree : SELF
alternatives:
alternative Asc:
visit 0:
local annotatedTree : _
local originalTree : _
alternative Desc:
visit 0:
local annotatedTree : _
local originalTree : _
-}
data Direction = Asc
| Desc
deriving ( Data,Eq,Show,Typeable)
-- cata
sem_Direction :: Direction ->
T_Direction
sem_Direction (Asc ) =
(sem_Direction_Asc )
sem_Direction (Desc ) =
(sem_Direction_Desc )
-- semantic domain
type T_Direction = Catalog ->
LocalIdentifierBindings ->
( Direction,Direction)
data Inh_Direction = Inh_Direction {cat_Inh_Direction :: Catalog,lib_Inh_Direction :: LocalIdentifierBindings}
data Syn_Direction = Syn_Direction {annotatedTree_Syn_Direction :: Direction,originalTree_Syn_Direction :: Direction}
wrap_Direction :: T_Direction ->
Inh_Direction ->
Syn_Direction
wrap_Direction sem (Inh_Direction _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_Direction _lhsOannotatedTree _lhsOoriginalTree ))
sem_Direction_Asc :: T_Direction
sem_Direction_Asc =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: Direction
_lhsOoriginalTree :: Direction
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
Asc
{-# LINE 2156 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
Asc
{-# LINE 2161 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 2166 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 2171 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
sem_Direction_Desc :: T_Direction
sem_Direction_Desc =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: Direction
_lhsOoriginalTree :: Direction
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
Desc
{-# LINE 2183 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
Desc
{-# LINE 2188 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 2193 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 2198 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
-- Distinct ----------------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
originalTree : SELF
alternatives:
alternative Distinct:
visit 0:
local annotatedTree : _
local originalTree : _
alternative Dupes:
visit 0:
local annotatedTree : _
local originalTree : _
-}
data Distinct = Distinct
| Dupes
deriving ( Data,Eq,Show,Typeable)
-- cata
sem_Distinct :: Distinct ->
T_Distinct
sem_Distinct (Distinct ) =
(sem_Distinct_Distinct )
sem_Distinct (Dupes ) =
(sem_Distinct_Dupes )
-- semantic domain
type T_Distinct = Catalog ->
LocalIdentifierBindings ->
( Distinct,Distinct)
data Inh_Distinct = Inh_Distinct {cat_Inh_Distinct :: Catalog,lib_Inh_Distinct :: LocalIdentifierBindings}
data Syn_Distinct = Syn_Distinct {annotatedTree_Syn_Distinct :: Distinct,originalTree_Syn_Distinct :: Distinct}
wrap_Distinct :: T_Distinct ->
Inh_Distinct ->
Syn_Distinct
wrap_Distinct sem (Inh_Distinct _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_Distinct _lhsOannotatedTree _lhsOoriginalTree ))
sem_Distinct_Distinct :: T_Distinct
sem_Distinct_Distinct =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: Distinct
_lhsOoriginalTree :: Distinct
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
Distinct
{-# LINE 2252 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
Distinct
{-# LINE 2257 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 2262 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 2267 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
sem_Distinct_Dupes :: T_Distinct
sem_Distinct_Dupes =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: Distinct
_lhsOoriginalTree :: Distinct
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
Dupes
{-# LINE 2279 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
Dupes
{-# LINE 2284 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 2289 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 2294 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
-- DropType ----------------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
originalTree : SELF
alternatives:
alternative Domain:
visit 0:
local annotatedTree : _
local originalTree : _
alternative Table:
visit 0:
local annotatedTree : _
local originalTree : _
alternative Type:
visit 0:
local annotatedTree : _
local originalTree : _
alternative View:
visit 0:
local annotatedTree : _
local originalTree : _
-}
data DropType = Domain
| Table
| Type
| View
deriving ( Data,Eq,Show,Typeable)
-- cata
sem_DropType :: DropType ->
T_DropType
sem_DropType (Domain ) =
(sem_DropType_Domain )
sem_DropType (Table ) =
(sem_DropType_Table )
sem_DropType (Type ) =
(sem_DropType_Type )
sem_DropType (View ) =
(sem_DropType_View )
-- semantic domain
type T_DropType = Catalog ->
LocalIdentifierBindings ->
( DropType,DropType)
data Inh_DropType = Inh_DropType {cat_Inh_DropType :: Catalog,lib_Inh_DropType :: LocalIdentifierBindings}
data Syn_DropType = Syn_DropType {annotatedTree_Syn_DropType :: DropType,originalTree_Syn_DropType :: DropType}
wrap_DropType :: T_DropType ->
Inh_DropType ->
Syn_DropType
wrap_DropType sem (Inh_DropType _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_DropType _lhsOannotatedTree _lhsOoriginalTree ))
sem_DropType_Domain :: T_DropType
sem_DropType_Domain =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: DropType
_lhsOoriginalTree :: DropType
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
Domain
{-# LINE 2362 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
Domain
{-# LINE 2367 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 2372 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 2377 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
sem_DropType_Table :: T_DropType
sem_DropType_Table =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: DropType
_lhsOoriginalTree :: DropType
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
Table
{-# LINE 2389 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
Table
{-# LINE 2394 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 2399 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 2404 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
sem_DropType_Type :: T_DropType
sem_DropType_Type =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: DropType
_lhsOoriginalTree :: DropType
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
Type
{-# LINE 2416 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
Type
{-# LINE 2421 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 2426 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 2431 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
sem_DropType_View :: T_DropType
sem_DropType_View =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: DropType
_lhsOoriginalTree :: DropType
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
View
{-# LINE 2443 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
View
{-# LINE 2448 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 2453 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 2458 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
-- Expression --------------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
liftedColumnName : String
originalTree : SELF
alternatives:
alternative BooleanLit:
child ann : {Annotation}
child b : {Bool}
visit 0:
local prototype : {Maybe FunctionPrototype}
local tpe : _
local backTree : _
local annotatedTree : _
local originalTree : _
alternative Case:
child ann : {Annotation}
child cases : CaseExpressionListExpressionPairList
child els : MaybeExpression
visit 0:
local prototype : {Maybe FunctionPrototype}
local whenTypes : _
local thenTypes : _
local tpe : _
local backTree : _
local annotatedTree : _
local originalTree : _
alternative CaseSimple:
child ann : {Annotation}
child value : Expression
child cases : CaseExpressionListExpressionPairList
child els : MaybeExpression
visit 0:
local prototype : {Maybe FunctionPrototype}
local whenTypes : _
local thenTypes : _
local tpe : _
local backTree : _
local annotatedTree : _
local originalTree : _
alternative Cast:
child ann : {Annotation}
child expr : Expression
child tn : TypeName
visit 0:
local prototype : {Maybe FunctionPrototype}
local tpe : _
local backTree : _
local annotatedTree : _
local originalTree : _
alternative Exists:
child ann : {Annotation}
child sel : SelectExpression
visit 0:
local prototype : {Maybe FunctionPrototype}
local tpe : _
local backTree : _
local annotatedTree : _
local originalTree : _
alternative FloatLit:
child ann : {Annotation}
child d : {Double}
visit 0:
local prototype : {Maybe FunctionPrototype}
local tpe : _
local backTree : _
local annotatedTree : _
local originalTree : _
alternative FunCall:
child ann : {Annotation}
child funName : {String}
child args : ExpressionList
visit 0:
local _tup1 : _
local tpe : _
local prototype : {Maybe FunctionPrototype}
local backTree : _
local annotatedTree : _
local originalTree : _
alternative Identifier:
child ann : {Annotation}
child i : {String}
visit 0:
local prototype : {Maybe FunctionPrototype}
local tpe : _
local backTree : _
local annotatedTree : _
local originalTree : _
alternative InPredicate:
child ann : {Annotation}
child expr : Expression
child i : {Bool}
child list : InList
visit 0:
local prototype : {Maybe FunctionPrototype}
local tpe : _
local backTree : _
local annotatedTree : _
local originalTree : _
alternative IntegerLit:
child ann : {Annotation}
child i : {Integer}
visit 0:
local prototype : {Maybe FunctionPrototype}
local tpe : _
local backTree : _
local annotatedTree : _
local originalTree : _
alternative LiftOperator:
child ann : {Annotation}
child oper : {String}
child flav : LiftFlavour
child args : ExpressionList
visit 0:
local prototype : {Maybe FunctionPrototype}
local tpe : _
local backTree : _
local annotatedTree : _
local originalTree : _
alternative NullLit:
child ann : {Annotation}
visit 0:
local prototype : {Maybe FunctionPrototype}
local tpe : _
local backTree : _
local annotatedTree : _
local originalTree : _
alternative Placeholder:
child ann : {Annotation}
visit 0:
local prototype : {Maybe FunctionPrototype}
local tpe : _
local backTree : _
local annotatedTree : _
local originalTree : _
alternative PositionalArg:
child ann : {Annotation}
child p : {Integer}
visit 0:
local prototype : {Maybe FunctionPrototype}
local tpe : _
local backTree : _
local annotatedTree : _
local originalTree : _
alternative ScalarSubQuery:
child ann : {Annotation}
child sel : SelectExpression
visit 0:
local prototype : {Maybe FunctionPrototype}
local tpe : _
local backTree : _
local annotatedTree : _
local originalTree : _
alternative StringLit:
child ann : {Annotation}
child quote : {String}
child value : {String}
visit 0:
local prototype : {Maybe FunctionPrototype}
local tpe : _
local backTree : _
local annotatedTree : _
local originalTree : _
alternative WindowFn:
child ann : {Annotation}
child fn : Expression
child partitionBy : ExpressionList
child orderBy : ExpressionList
child dir : Direction
child frm : FrameClause
visit 0:
local prototype : {Maybe FunctionPrototype}
local tpe : _
local backTree : _
local annotatedTree : _
local originalTree : _
-}
data Expression = BooleanLit (Annotation) (Bool)
| Case (Annotation) (CaseExpressionListExpressionPairList) (MaybeExpression)
| CaseSimple (Annotation) (Expression) (CaseExpressionListExpressionPairList) (MaybeExpression)
| Cast (Annotation) (Expression) (TypeName)
| Exists (Annotation) (SelectExpression)
| FloatLit (Annotation) (Double)
| FunCall (Annotation) (String) (ExpressionList)
| Identifier (Annotation) (String)
| InPredicate (Annotation) (Expression) (Bool) (InList)
| IntegerLit (Annotation) (Integer)
| LiftOperator (Annotation) (String) (LiftFlavour) (ExpressionList)
| NullLit (Annotation)
| Placeholder (Annotation)
| PositionalArg (Annotation) (Integer)
| ScalarSubQuery (Annotation) (SelectExpression)
| StringLit (Annotation) (String) (String)
| WindowFn (Annotation) (Expression) (ExpressionList) (ExpressionList) (Direction) (FrameClause)
deriving ( Data,Eq,Show,Typeable)
-- cata
sem_Expression :: Expression ->
T_Expression
sem_Expression (BooleanLit _ann _b ) =
(sem_Expression_BooleanLit _ann _b )
sem_Expression (Case _ann _cases _els ) =
(sem_Expression_Case _ann (sem_CaseExpressionListExpressionPairList _cases ) (sem_MaybeExpression _els ) )
sem_Expression (CaseSimple _ann _value _cases _els ) =
(sem_Expression_CaseSimple _ann (sem_Expression _value ) (sem_CaseExpressionListExpressionPairList _cases ) (sem_MaybeExpression _els ) )
sem_Expression (Cast _ann _expr _tn ) =
(sem_Expression_Cast _ann (sem_Expression _expr ) (sem_TypeName _tn ) )
sem_Expression (Exists _ann _sel ) =
(sem_Expression_Exists _ann (sem_SelectExpression _sel ) )
sem_Expression (FloatLit _ann _d ) =
(sem_Expression_FloatLit _ann _d )
sem_Expression (FunCall _ann _funName _args ) =
(sem_Expression_FunCall _ann _funName (sem_ExpressionList _args ) )
sem_Expression (Identifier _ann _i ) =
(sem_Expression_Identifier _ann _i )
sem_Expression (InPredicate _ann _expr _i _list ) =
(sem_Expression_InPredicate _ann (sem_Expression _expr ) _i (sem_InList _list ) )
sem_Expression (IntegerLit _ann _i ) =
(sem_Expression_IntegerLit _ann _i )
sem_Expression (LiftOperator _ann _oper _flav _args ) =
(sem_Expression_LiftOperator _ann _oper (sem_LiftFlavour _flav ) (sem_ExpressionList _args ) )
sem_Expression (NullLit _ann ) =
(sem_Expression_NullLit _ann )
sem_Expression (Placeholder _ann ) =
(sem_Expression_Placeholder _ann )
sem_Expression (PositionalArg _ann _p ) =
(sem_Expression_PositionalArg _ann _p )
sem_Expression (ScalarSubQuery _ann _sel ) =
(sem_Expression_ScalarSubQuery _ann (sem_SelectExpression _sel ) )
sem_Expression (StringLit _ann _quote _value ) =
(sem_Expression_StringLit _ann _quote _value )
sem_Expression (WindowFn _ann _fn _partitionBy _orderBy _dir _frm ) =
(sem_Expression_WindowFn _ann (sem_Expression _fn ) (sem_ExpressionList _partitionBy ) (sem_ExpressionList _orderBy ) (sem_Direction _dir ) (sem_FrameClause _frm ) )
-- semantic domain
type T_Expression = Catalog ->
LocalIdentifierBindings ->
( Expression,String,Expression)
data Inh_Expression = Inh_Expression {cat_Inh_Expression :: Catalog,lib_Inh_Expression :: LocalIdentifierBindings}
data Syn_Expression = Syn_Expression {annotatedTree_Syn_Expression :: Expression,liftedColumnName_Syn_Expression :: String,originalTree_Syn_Expression :: Expression}
wrap_Expression :: T_Expression ->
Inh_Expression ->
Syn_Expression
wrap_Expression sem (Inh_Expression _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOliftedColumnName,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_Expression _lhsOannotatedTree _lhsOliftedColumnName _lhsOoriginalTree ))
sem_Expression_BooleanLit :: Annotation ->
Bool ->
T_Expression
sem_Expression_BooleanLit ann_ b_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: Expression
_prototype :: (Maybe FunctionPrototype)
_lhsOliftedColumnName :: String
_lhsOoriginalTree :: Expression
-- "./TypeChecking/Expressions.ag"(line 14, column 9)
_lhsOannotatedTree =
{-# LINE 14 "./TypeChecking/Expressions.ag" #-}
annTypesAndErrors _backTree
(tpeToT _tpe )
(getErrors _tpe )
$ fmap ((:[]) . FunctionPrototypeA) _prototype
{-# LINE 2727 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 29, column 9)
_prototype =
{-# LINE 29 "./TypeChecking/Expressions.ag" #-}
Nothing
{-# LINE 2732 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 41, column 19)
_tpe =
{-# LINE 41 "./TypeChecking/Expressions.ag" #-}
Right typeBool
{-# LINE 2737 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 53, column 9)
_backTree =
{-# LINE 53 "./TypeChecking/Expressions.ag" #-}
BooleanLit ann_ b_
{-# LINE 2742 "AstInternal.hs" #-}
-- "./TypeChecking/SelectLists.ag"(line 177, column 7)
_lhsOliftedColumnName =
{-# LINE 177 "./TypeChecking/SelectLists.ag" #-}
""
{-# LINE 2747 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
BooleanLit ann_ b_
{-# LINE 2752 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
BooleanLit ann_ b_
{-# LINE 2757 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 2762 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOliftedColumnName,_lhsOoriginalTree)))
sem_Expression_Case :: Annotation ->
T_CaseExpressionListExpressionPairList ->
T_MaybeExpression ->
T_Expression
sem_Expression_Case ann_ cases_ els_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: Expression
_prototype :: (Maybe FunctionPrototype)
_lhsOliftedColumnName :: String
_lhsOoriginalTree :: Expression
_casesOcat :: Catalog
_casesOlib :: LocalIdentifierBindings
_elsOcat :: Catalog
_elsOlib :: LocalIdentifierBindings
_casesIannotatedTree :: CaseExpressionListExpressionPairList
_casesIoriginalTree :: CaseExpressionListExpressionPairList
_elsIannotatedTree :: MaybeExpression
_elsIoriginalTree :: MaybeExpression
-- "./TypeChecking/Expressions.ag"(line 14, column 9)
_lhsOannotatedTree =
{-# LINE 14 "./TypeChecking/Expressions.ag" #-}
annTypesAndErrors _backTree
(tpeToT _tpe )
(getErrors _tpe )
$ fmap ((:[]) . FunctionPrototypeA) _prototype
{-# LINE 2790 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 29, column 9)
_prototype =
{-# LINE 29 "./TypeChecking/Expressions.ag" #-}
Nothing
{-# LINE 2795 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 202, column 9)
_whenTypes =
{-# LINE 202 "./TypeChecking/Expressions.ag" #-}
map getTypeAnnotation $ concatMap fst $
_casesIannotatedTree
{-# LINE 2801 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 204, column 9)
_thenTypes =
{-# LINE 204 "./TypeChecking/Expressions.ag" #-}
map getTypeAnnotation $
(map snd $ _casesIannotatedTree) ++
maybeToList _elsIannotatedTree
{-# LINE 2808 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 210, column 9)
_tpe =
{-# LINE 210 "./TypeChecking/Expressions.ag" #-}
dependsOnRTpe _whenTypes $ do
errorWhen (any (/= typeBool) _whenTypes ) $
[WrongTypes typeBool _whenTypes ]
dependsOnRTpe _thenTypes $
resolveResultSetType _lhsIcat _thenTypes
{-# LINE 2817 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 216, column 9)
_backTree =
{-# LINE 216 "./TypeChecking/Expressions.ag" #-}
Case ann_ _casesIannotatedTree _elsIannotatedTree
{-# LINE 2822 "AstInternal.hs" #-}
-- "./TypeChecking/SelectLists.ag"(line 177, column 7)
_lhsOliftedColumnName =
{-# LINE 177 "./TypeChecking/SelectLists.ag" #-}
""
{-# LINE 2827 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
Case ann_ _casesIannotatedTree _elsIannotatedTree
{-# LINE 2832 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
Case ann_ _casesIoriginalTree _elsIoriginalTree
{-# LINE 2837 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 2842 "AstInternal.hs" #-}
-- copy rule (down)
_casesOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 2847 "AstInternal.hs" #-}
-- copy rule (down)
_casesOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 2852 "AstInternal.hs" #-}
-- copy rule (down)
_elsOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 2857 "AstInternal.hs" #-}
-- copy rule (down)
_elsOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 2862 "AstInternal.hs" #-}
( _casesIannotatedTree,_casesIoriginalTree) =
(cases_ _casesOcat _casesOlib )
( _elsIannotatedTree,_elsIoriginalTree) =
(els_ _elsOcat _elsOlib )
in ( _lhsOannotatedTree,_lhsOliftedColumnName,_lhsOoriginalTree)))
sem_Expression_CaseSimple :: Annotation ->
T_Expression ->
T_CaseExpressionListExpressionPairList ->
T_MaybeExpression ->
T_Expression
sem_Expression_CaseSimple ann_ value_ cases_ els_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: Expression
_prototype :: (Maybe FunctionPrototype)
_lhsOoriginalTree :: Expression
_lhsOliftedColumnName :: String
_valueOcat :: Catalog
_valueOlib :: LocalIdentifierBindings
_casesOcat :: Catalog
_casesOlib :: LocalIdentifierBindings
_elsOcat :: Catalog
_elsOlib :: LocalIdentifierBindings
_valueIannotatedTree :: Expression
_valueIliftedColumnName :: String
_valueIoriginalTree :: Expression
_casesIannotatedTree :: CaseExpressionListExpressionPairList
_casesIoriginalTree :: CaseExpressionListExpressionPairList
_elsIannotatedTree :: MaybeExpression
_elsIoriginalTree :: MaybeExpression
-- "./TypeChecking/Expressions.ag"(line 14, column 9)
_lhsOannotatedTree =
{-# LINE 14 "./TypeChecking/Expressions.ag" #-}
annTypesAndErrors _backTree
(tpeToT _tpe )
(getErrors _tpe )
$ fmap ((:[]) . FunctionPrototypeA) _prototype
{-# LINE 2900 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 29, column 9)
_prototype =
{-# LINE 29 "./TypeChecking/Expressions.ag" #-}
Nothing
{-# LINE 2905 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 202, column 9)
_whenTypes =
{-# LINE 202 "./TypeChecking/Expressions.ag" #-}
map getTypeAnnotation $ concatMap fst $
_casesIannotatedTree
{-# LINE 2911 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 204, column 9)
_thenTypes =
{-# LINE 204 "./TypeChecking/Expressions.ag" #-}
map getTypeAnnotation $
(map snd $ _casesIannotatedTree) ++
maybeToList _elsIannotatedTree
{-# LINE 2918 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 221, column 9)
_tpe =
{-# LINE 221 "./TypeChecking/Expressions.ag" #-}
dependsOnRTpe _whenTypes $ do
let valueType = getTypeAnnotation _valueIannotatedTree
checkWhenTypes <-
resolveResultSetType _lhsIcat (valueType : _whenTypes )
dependsOnRTpe _thenTypes $
resolveResultSetType _lhsIcat _thenTypes
{-# LINE 2928 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 228, column 9)
_backTree =
{-# LINE 228 "./TypeChecking/Expressions.ag" #-}
CaseSimple ann_
_valueIannotatedTree
_casesIannotatedTree
_elsIannotatedTree
{-# LINE 2936 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
CaseSimple ann_ _valueIannotatedTree _casesIannotatedTree _elsIannotatedTree
{-# LINE 2941 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
CaseSimple ann_ _valueIoriginalTree _casesIoriginalTree _elsIoriginalTree
{-# LINE 2946 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 2951 "AstInternal.hs" #-}
-- copy rule (up)
_lhsOliftedColumnName =
{-# LINE 161 "./TypeChecking/SelectLists.ag" #-}
_valueIliftedColumnName
{-# LINE 2956 "AstInternal.hs" #-}
-- copy rule (down)
_valueOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 2961 "AstInternal.hs" #-}
-- copy rule (down)
_valueOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 2966 "AstInternal.hs" #-}
-- copy rule (down)
_casesOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 2971 "AstInternal.hs" #-}
-- copy rule (down)
_casesOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 2976 "AstInternal.hs" #-}
-- copy rule (down)
_elsOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 2981 "AstInternal.hs" #-}
-- copy rule (down)
_elsOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 2986 "AstInternal.hs" #-}
( _valueIannotatedTree,_valueIliftedColumnName,_valueIoriginalTree) =
(value_ _valueOcat _valueOlib )
( _casesIannotatedTree,_casesIoriginalTree) =
(cases_ _casesOcat _casesOlib )
( _elsIannotatedTree,_elsIoriginalTree) =
(els_ _elsOcat _elsOlib )
in ( _lhsOannotatedTree,_lhsOliftedColumnName,_lhsOoriginalTree)))
sem_Expression_Cast :: Annotation ->
T_Expression ->
T_TypeName ->
T_Expression
sem_Expression_Cast ann_ expr_ tn_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: Expression
_prototype :: (Maybe FunctionPrototype)
_lhsOliftedColumnName :: String
_lhsOoriginalTree :: Expression
_exprOcat :: Catalog
_exprOlib :: LocalIdentifierBindings
_tnOcat :: Catalog
_tnOlib :: LocalIdentifierBindings
_exprIannotatedTree :: Expression
_exprIliftedColumnName :: String
_exprIoriginalTree :: Expression
_tnIannotatedTree :: TypeName
_tnInamedType :: Type
_tnIoriginalTree :: TypeName
-- "./TypeChecking/Expressions.ag"(line 14, column 9)
_lhsOannotatedTree =
{-# LINE 14 "./TypeChecking/Expressions.ag" #-}
annTypesAndErrors _backTree
(tpeToT _tpe )
(getErrors _tpe )
$ fmap ((:[]) . FunctionPrototypeA) _prototype
{-# LINE 3022 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 29, column 9)
_prototype =
{-# LINE 29 "./TypeChecking/Expressions.ag" #-}
Nothing
{-# LINE 3027 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 66, column 12)
_tpe =
{-# LINE 66 "./TypeChecking/Expressions.ag" #-}
Right $ _tnInamedType
{-# LINE 3032 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 67, column 12)
_backTree =
{-# LINE 67 "./TypeChecking/Expressions.ag" #-}
Cast ann_ _exprIannotatedTree _tnIannotatedTree
{-# LINE 3037 "AstInternal.hs" #-}
-- "./TypeChecking/SelectLists.ag"(line 169, column 10)
_lhsOliftedColumnName =
{-# LINE 169 "./TypeChecking/SelectLists.ag" #-}
case _tnIannotatedTree of
SimpleTypeName _ tn -> tn
_ -> ""
{-# LINE 3044 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
Cast ann_ _exprIannotatedTree _tnIannotatedTree
{-# LINE 3049 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
Cast ann_ _exprIoriginalTree _tnIoriginalTree
{-# LINE 3054 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 3059 "AstInternal.hs" #-}
-- copy rule (down)
_exprOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 3064 "AstInternal.hs" #-}
-- copy rule (down)
_exprOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 3069 "AstInternal.hs" #-}
-- copy rule (down)
_tnOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 3074 "AstInternal.hs" #-}
-- copy rule (down)
_tnOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 3079 "AstInternal.hs" #-}
( _exprIannotatedTree,_exprIliftedColumnName,_exprIoriginalTree) =
(expr_ _exprOcat _exprOlib )
( _tnIannotatedTree,_tnInamedType,_tnIoriginalTree) =
(tn_ _tnOcat _tnOlib )
in ( _lhsOannotatedTree,_lhsOliftedColumnName,_lhsOoriginalTree)))
sem_Expression_Exists :: Annotation ->
T_SelectExpression ->
T_Expression
sem_Expression_Exists ann_ sel_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: Expression
_prototype :: (Maybe FunctionPrototype)
_lhsOliftedColumnName :: String
_lhsOoriginalTree :: Expression
_selOcat :: Catalog
_selOlib :: LocalIdentifierBindings
_selIannotatedTree :: SelectExpression
_selIlibUpdates :: ([LocalIdentifierBindingsUpdate])
_selIoriginalTree :: SelectExpression
-- "./TypeChecking/Expressions.ag"(line 14, column 9)
_lhsOannotatedTree =
{-# LINE 14 "./TypeChecking/Expressions.ag" #-}
annTypesAndErrors _backTree
(tpeToT _tpe )
(getErrors _tpe )
$ fmap ((:[]) . FunctionPrototypeA) _prototype
{-# LINE 3107 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 29, column 9)
_prototype =
{-# LINE 29 "./TypeChecking/Expressions.ag" #-}
Nothing
{-# LINE 3112 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 259, column 9)
_tpe =
{-# LINE 259 "./TypeChecking/Expressions.ag" #-}
Right typeBool
{-# LINE 3117 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 260, column 9)
_backTree =
{-# LINE 260 "./TypeChecking/Expressions.ag" #-}
Exists ann_ _selIannotatedTree
{-# LINE 3122 "AstInternal.hs" #-}
-- "./TypeChecking/SelectLists.ag"(line 177, column 7)
_lhsOliftedColumnName =
{-# LINE 177 "./TypeChecking/SelectLists.ag" #-}
""
{-# LINE 3127 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
Exists ann_ _selIannotatedTree
{-# LINE 3132 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
Exists ann_ _selIoriginalTree
{-# LINE 3137 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 3142 "AstInternal.hs" #-}
-- copy rule (down)
_selOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 3147 "AstInternal.hs" #-}
-- copy rule (down)
_selOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 3152 "AstInternal.hs" #-}
( _selIannotatedTree,_selIlibUpdates,_selIoriginalTree) =
(sel_ _selOcat _selOlib )
in ( _lhsOannotatedTree,_lhsOliftedColumnName,_lhsOoriginalTree)))
sem_Expression_FloatLit :: Annotation ->
Double ->
T_Expression
sem_Expression_FloatLit ann_ d_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: Expression
_prototype :: (Maybe FunctionPrototype)
_lhsOliftedColumnName :: String
_lhsOoriginalTree :: Expression
-- "./TypeChecking/Expressions.ag"(line 14, column 9)
_lhsOannotatedTree =
{-# LINE 14 "./TypeChecking/Expressions.ag" #-}
annTypesAndErrors _backTree
(tpeToT _tpe )
(getErrors _tpe )
$ fmap ((:[]) . FunctionPrototypeA) _prototype
{-# LINE 3173 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 29, column 9)
_prototype =
{-# LINE 29 "./TypeChecking/Expressions.ag" #-}
Nothing
{-# LINE 3178 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 40, column 17)
_tpe =
{-# LINE 40 "./TypeChecking/Expressions.ag" #-}
Right typeNumeric
{-# LINE 3183 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 51, column 9)
_backTree =
{-# LINE 51 "./TypeChecking/Expressions.ag" #-}
FloatLit ann_ d_
{-# LINE 3188 "AstInternal.hs" #-}
-- "./TypeChecking/SelectLists.ag"(line 177, column 7)
_lhsOliftedColumnName =
{-# LINE 177 "./TypeChecking/SelectLists.ag" #-}
""
{-# LINE 3193 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
FloatLit ann_ d_
{-# LINE 3198 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
FloatLit ann_ d_
{-# LINE 3203 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 3208 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOliftedColumnName,_lhsOoriginalTree)))
sem_Expression_FunCall :: Annotation ->
String ->
T_ExpressionList ->
T_Expression
sem_Expression_FunCall ann_ funName_ args_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: Expression
_prototype :: (Maybe FunctionPrototype)
_lhsOliftedColumnName :: String
_lhsOoriginalTree :: Expression
_argsOcat :: Catalog
_argsOlib :: LocalIdentifierBindings
_argsIannotatedTree :: ExpressionList
_argsIoriginalTree :: ExpressionList
_argsItypeList :: ([Type])
-- "./TypeChecking/Expressions.ag"(line 14, column 9)
_lhsOannotatedTree =
{-# LINE 14 "./TypeChecking/Expressions.ag" #-}
annTypesAndErrors _backTree
(tpeToT _tpe )
(getErrors _tpe )
$ fmap ((:[]) . FunctionPrototypeA) _prototype
{-# LINE 3233 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 74, column 9)
__tup1 =
{-# LINE 74 "./TypeChecking/Expressions.ag" #-}
if any (==TypeCheckFailed) _argsItypeList
then (Right TypeCheckFailed, Nothing)
else
let fe = typeCheckFunCall
_lhsIcat
funName_
_argsItypeList
in (dependsOnRTpe _argsItypeList $ fmap (\(_,_,r,_) -> r) fe
,eitherToMaybe fe)
{-# LINE 3246 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 74, column 9)
(_tpe,_) =
{-# LINE 74 "./TypeChecking/Expressions.ag" #-}
__tup1
{-# LINE 3251 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 74, column 9)
(_,_prototype) =
{-# LINE 74 "./TypeChecking/Expressions.ag" #-}
__tup1
{-# LINE 3256 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 83, column 9)
_backTree =
{-# LINE 83 "./TypeChecking/Expressions.ag" #-}
FunCall ann_ funName_ _argsIannotatedTree
{-# LINE 3261 "AstInternal.hs" #-}
-- "./TypeChecking/SelectLists.ag"(line 165, column 13)
_lhsOliftedColumnName =
{-# LINE 165 "./TypeChecking/SelectLists.ag" #-}
if isOperatorName funName_
then ""
else funName_
{-# LINE 3268 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
FunCall ann_ funName_ _argsIannotatedTree
{-# LINE 3273 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
FunCall ann_ funName_ _argsIoriginalTree
{-# LINE 3278 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 3283 "AstInternal.hs" #-}
-- copy rule (down)
_argsOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 3288 "AstInternal.hs" #-}
-- copy rule (down)
_argsOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 3293 "AstInternal.hs" #-}
( _argsIannotatedTree,_argsIoriginalTree,_argsItypeList) =
(args_ _argsOcat _argsOlib )
in ( _lhsOannotatedTree,_lhsOliftedColumnName,_lhsOoriginalTree)))
sem_Expression_Identifier :: Annotation ->
String ->
T_Expression
sem_Expression_Identifier ann_ i_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: Expression
_prototype :: (Maybe FunctionPrototype)
_lhsOliftedColumnName :: String
_lhsOoriginalTree :: Expression
-- "./TypeChecking/Expressions.ag"(line 14, column 9)
_lhsOannotatedTree =
{-# LINE 14 "./TypeChecking/Expressions.ag" #-}
annTypesAndErrors _backTree
(tpeToT _tpe )
(getErrors _tpe )
$ fmap ((:[]) . FunctionPrototypeA) _prototype
{-# LINE 3314 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 29, column 9)
_prototype =
{-# LINE 29 "./TypeChecking/Expressions.ag" #-}
Nothing
{-# LINE 3319 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 241, column 9)
_tpe =
{-# LINE 241 "./TypeChecking/Expressions.ag" #-}
libLookupID _lhsIlib i_
{-# LINE 3324 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 242, column 9)
_backTree =
{-# LINE 242 "./TypeChecking/Expressions.ag" #-}
Identifier ann_ i_
{-# LINE 3329 "AstInternal.hs" #-}
-- "./TypeChecking/SelectLists.ag"(line 164, column 16)
_lhsOliftedColumnName =
{-# LINE 164 "./TypeChecking/SelectLists.ag" #-}
i_
{-# LINE 3334 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
Identifier ann_ i_
{-# LINE 3339 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
Identifier ann_ i_
{-# LINE 3344 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 3349 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOliftedColumnName,_lhsOoriginalTree)))
sem_Expression_InPredicate :: Annotation ->
T_Expression ->
Bool ->
T_InList ->
T_Expression
sem_Expression_InPredicate ann_ expr_ i_ list_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: Expression
_prototype :: (Maybe FunctionPrototype)
_lhsOoriginalTree :: Expression
_lhsOliftedColumnName :: String
_exprOcat :: Catalog
_exprOlib :: LocalIdentifierBindings
_listOcat :: Catalog
_listOlib :: LocalIdentifierBindings
_exprIannotatedTree :: Expression
_exprIliftedColumnName :: String
_exprIoriginalTree :: Expression
_listIannotatedTree :: InList
_listIlistType :: (Either [TypeError] Type)
_listIoriginalTree :: InList
-- "./TypeChecking/Expressions.ag"(line 14, column 9)
_lhsOannotatedTree =
{-# LINE 14 "./TypeChecking/Expressions.ag" #-}
annTypesAndErrors _backTree
(tpeToT _tpe )
(getErrors _tpe )
$ fmap ((:[]) . FunctionPrototypeA) _prototype
{-# LINE 3380 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 29, column 9)
_prototype =
{-# LINE 29 "./TypeChecking/Expressions.ag" #-}
Nothing
{-# LINE 3385 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 289, column 9)
_tpe =
{-# LINE 289 "./TypeChecking/Expressions.ag" #-}
do
lt <- _listIlistType
ty <- resolveResultSetType
_lhsIcat
[getTypeAnnotation _exprIannotatedTree, lt]
return typeBool
{-# LINE 3395 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 295, column 9)
_backTree =
{-# LINE 295 "./TypeChecking/Expressions.ag" #-}
InPredicate ann_
_exprIannotatedTree
i_
_listIannotatedTree
{-# LINE 3403 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
InPredicate ann_ _exprIannotatedTree i_ _listIannotatedTree
{-# LINE 3408 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
InPredicate ann_ _exprIoriginalTree i_ _listIoriginalTree
{-# LINE 3413 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 3418 "AstInternal.hs" #-}
-- copy rule (up)
_lhsOliftedColumnName =
{-# LINE 161 "./TypeChecking/SelectLists.ag" #-}
_exprIliftedColumnName
{-# LINE 3423 "AstInternal.hs" #-}
-- copy rule (down)
_exprOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 3428 "AstInternal.hs" #-}
-- copy rule (down)
_exprOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 3433 "AstInternal.hs" #-}
-- copy rule (down)
_listOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 3438 "AstInternal.hs" #-}
-- copy rule (down)
_listOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 3443 "AstInternal.hs" #-}
( _exprIannotatedTree,_exprIliftedColumnName,_exprIoriginalTree) =
(expr_ _exprOcat _exprOlib )
( _listIannotatedTree,_listIlistType,_listIoriginalTree) =
(list_ _listOcat _listOlib )
in ( _lhsOannotatedTree,_lhsOliftedColumnName,_lhsOoriginalTree)))
sem_Expression_IntegerLit :: Annotation ->
Integer ->
T_Expression
sem_Expression_IntegerLit ann_ i_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: Expression
_prototype :: (Maybe FunctionPrototype)
_lhsOliftedColumnName :: String
_lhsOoriginalTree :: Expression
-- "./TypeChecking/Expressions.ag"(line 14, column 9)
_lhsOannotatedTree =
{-# LINE 14 "./TypeChecking/Expressions.ag" #-}
annTypesAndErrors _backTree
(tpeToT _tpe )
(getErrors _tpe )
$ fmap ((:[]) . FunctionPrototypeA) _prototype
{-# LINE 3466 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 29, column 9)
_prototype =
{-# LINE 29 "./TypeChecking/Expressions.ag" #-}
Nothing
{-# LINE 3471 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 38, column 19)
_tpe =
{-# LINE 38 "./TypeChecking/Expressions.ag" #-}
Right typeInt
{-# LINE 3476 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 47, column 9)
_backTree =
{-# LINE 47 "./TypeChecking/Expressions.ag" #-}
IntegerLit ann_ i_
{-# LINE 3481 "AstInternal.hs" #-}
-- "./TypeChecking/SelectLists.ag"(line 177, column 7)
_lhsOliftedColumnName =
{-# LINE 177 "./TypeChecking/SelectLists.ag" #-}
""
{-# LINE 3486 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
IntegerLit ann_ i_
{-# LINE 3491 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
IntegerLit ann_ i_
{-# LINE 3496 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 3501 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOliftedColumnName,_lhsOoriginalTree)))
sem_Expression_LiftOperator :: Annotation ->
String ->
T_LiftFlavour ->
T_ExpressionList ->
T_Expression
sem_Expression_LiftOperator ann_ oper_ flav_ args_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: Expression
_prototype :: (Maybe FunctionPrototype)
_lhsOliftedColumnName :: String
_lhsOoriginalTree :: Expression
_flavOcat :: Catalog
_flavOlib :: LocalIdentifierBindings
_argsOcat :: Catalog
_argsOlib :: LocalIdentifierBindings
_flavIannotatedTree :: LiftFlavour
_flavIoriginalTree :: LiftFlavour
_argsIannotatedTree :: ExpressionList
_argsIoriginalTree :: ExpressionList
_argsItypeList :: ([Type])
-- "./TypeChecking/Expressions.ag"(line 14, column 9)
_lhsOannotatedTree =
{-# LINE 14 "./TypeChecking/Expressions.ag" #-}
annTypesAndErrors _backTree
(tpeToT _tpe )
(getErrors _tpe )
$ fmap ((:[]) . FunctionPrototypeA) _prototype
{-# LINE 3531 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 29, column 9)
_prototype =
{-# LINE 29 "./TypeChecking/Expressions.ag" #-}
Nothing
{-# LINE 3536 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 167, column 9)
_tpe =
{-# LINE 167 "./TypeChecking/Expressions.ag" #-}
dependsOnRTpe _argsItypeList $ do
let args = _argsIannotatedTree
errorWhen (length args /= 2)
[AnyAllError $ "must have two args, got " ++ show args]
let [a,b] = args
aType = getTypeAnnotation a
bType = getTypeAnnotation b
dependsOnRTpe [aType,bType] $ do
errorWhen (not $ isArrayType bType)
[AnyAllError $ "second arg must be array, got " ++ show args]
elemType <- unwrapArray $ bType
resType <- fmap (\(_,_,r,_) -> r) $ typeCheckFunCall
_lhsIcat
oper_
[aType,elemType]
errorWhen (resType /= typeBool)
[AnyAllError $ "operator must have bool return, got " ++ show resType]
return resType
{-# LINE 3558 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 185, column 9)
_backTree =
{-# LINE 185 "./TypeChecking/Expressions.ag" #-}
LiftOperator ann_ oper_ _flavIannotatedTree _argsIannotatedTree
{-# LINE 3563 "AstInternal.hs" #-}
-- "./TypeChecking/SelectLists.ag"(line 177, column 7)
_lhsOliftedColumnName =
{-# LINE 177 "./TypeChecking/SelectLists.ag" #-}
""
{-# LINE 3568 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
LiftOperator ann_ oper_ _flavIannotatedTree _argsIannotatedTree
{-# LINE 3573 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
LiftOperator ann_ oper_ _flavIoriginalTree _argsIoriginalTree
{-# LINE 3578 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 3583 "AstInternal.hs" #-}
-- copy rule (down)
_flavOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 3588 "AstInternal.hs" #-}
-- copy rule (down)
_flavOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 3593 "AstInternal.hs" #-}
-- copy rule (down)
_argsOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 3598 "AstInternal.hs" #-}
-- copy rule (down)
_argsOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 3603 "AstInternal.hs" #-}
( _flavIannotatedTree,_flavIoriginalTree) =
(flav_ _flavOcat _flavOlib )
( _argsIannotatedTree,_argsIoriginalTree,_argsItypeList) =
(args_ _argsOcat _argsOlib )
in ( _lhsOannotatedTree,_lhsOliftedColumnName,_lhsOoriginalTree)))
sem_Expression_NullLit :: Annotation ->
T_Expression
sem_Expression_NullLit ann_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: Expression
_prototype :: (Maybe FunctionPrototype)
_lhsOliftedColumnName :: String
_lhsOoriginalTree :: Expression
-- "./TypeChecking/Expressions.ag"(line 14, column 9)
_lhsOannotatedTree =
{-# LINE 14 "./TypeChecking/Expressions.ag" #-}
annTypesAndErrors _backTree
(tpeToT _tpe )
(getErrors _tpe )
$ fmap ((:[]) . FunctionPrototypeA) _prototype
{-# LINE 3625 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 29, column 9)
_prototype =
{-# LINE 29 "./TypeChecking/Expressions.ag" #-}
Nothing
{-# LINE 3630 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 43, column 16)
_tpe =
{-# LINE 43 "./TypeChecking/Expressions.ag" #-}
Right UnknownType
{-# LINE 3635 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 55, column 9)
_backTree =
{-# LINE 55 "./TypeChecking/Expressions.ag" #-}
NullLit ann_
{-# LINE 3640 "AstInternal.hs" #-}
-- "./TypeChecking/SelectLists.ag"(line 177, column 7)
_lhsOliftedColumnName =
{-# LINE 177 "./TypeChecking/SelectLists.ag" #-}
""
{-# LINE 3645 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
NullLit ann_
{-# LINE 3650 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
NullLit ann_
{-# LINE 3655 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 3660 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOliftedColumnName,_lhsOoriginalTree)))
sem_Expression_Placeholder :: Annotation ->
T_Expression
sem_Expression_Placeholder ann_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: Expression
_prototype :: (Maybe FunctionPrototype)
_lhsOliftedColumnName :: String
_lhsOoriginalTree :: Expression
-- "./TypeChecking/Expressions.ag"(line 14, column 9)
_lhsOannotatedTree =
{-# LINE 14 "./TypeChecking/Expressions.ag" #-}
annTypesAndErrors _backTree
(tpeToT _tpe )
(getErrors _tpe )
$ fmap ((:[]) . FunctionPrototypeA) _prototype
{-# LINE 3678 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 29, column 9)
_prototype =
{-# LINE 29 "./TypeChecking/Expressions.ag" #-}
Nothing
{-# LINE 3683 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 253, column 9)
_tpe =
{-# LINE 253 "./TypeChecking/Expressions.ag" #-}
Right UnknownType
{-# LINE 3688 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 254, column 9)
_backTree =
{-# LINE 254 "./TypeChecking/Expressions.ag" #-}
Placeholder ann_
{-# LINE 3693 "AstInternal.hs" #-}
-- "./TypeChecking/SelectLists.ag"(line 177, column 7)
_lhsOliftedColumnName =
{-# LINE 177 "./TypeChecking/SelectLists.ag" #-}
""
{-# LINE 3698 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
Placeholder ann_
{-# LINE 3703 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
Placeholder ann_
{-# LINE 3708 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 3713 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOliftedColumnName,_lhsOoriginalTree)))
sem_Expression_PositionalArg :: Annotation ->
Integer ->
T_Expression
sem_Expression_PositionalArg ann_ p_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: Expression
_prototype :: (Maybe FunctionPrototype)
_lhsOliftedColumnName :: String
_lhsOoriginalTree :: Expression
-- "./TypeChecking/Expressions.ag"(line 14, column 9)
_lhsOannotatedTree =
{-# LINE 14 "./TypeChecking/Expressions.ag" #-}
annTypesAndErrors _backTree
(tpeToT _tpe )
(getErrors _tpe )
$ fmap ((:[]) . FunctionPrototypeA) _prototype
{-# LINE 3732 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 29, column 9)
_prototype =
{-# LINE 29 "./TypeChecking/Expressions.ag" #-}
Nothing
{-# LINE 3737 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 247, column 9)
_tpe =
{-# LINE 247 "./TypeChecking/Expressions.ag" #-}
libLookupID _lhsIlib ('$':show p_)
{-# LINE 3742 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 248, column 9)
_backTree =
{-# LINE 248 "./TypeChecking/Expressions.ag" #-}
PositionalArg ann_ p_
{-# LINE 3747 "AstInternal.hs" #-}
-- "./TypeChecking/SelectLists.ag"(line 177, column 7)
_lhsOliftedColumnName =
{-# LINE 177 "./TypeChecking/SelectLists.ag" #-}
""
{-# LINE 3752 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
PositionalArg ann_ p_
{-# LINE 3757 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
PositionalArg ann_ p_
{-# LINE 3762 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 3767 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOliftedColumnName,_lhsOoriginalTree)))
sem_Expression_ScalarSubQuery :: Annotation ->
T_SelectExpression ->
T_Expression
sem_Expression_ScalarSubQuery ann_ sel_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: Expression
_prototype :: (Maybe FunctionPrototype)
_lhsOliftedColumnName :: String
_lhsOoriginalTree :: Expression
_selOcat :: Catalog
_selOlib :: LocalIdentifierBindings
_selIannotatedTree :: SelectExpression
_selIlibUpdates :: ([LocalIdentifierBindingsUpdate])
_selIoriginalTree :: SelectExpression
-- "./TypeChecking/Expressions.ag"(line 14, column 9)
_lhsOannotatedTree =
{-# LINE 14 "./TypeChecking/Expressions.ag" #-}
annTypesAndErrors _backTree
(tpeToT _tpe )
(getErrors _tpe )
$ fmap ((:[]) . FunctionPrototypeA) _prototype
{-# LINE 3791 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 29, column 9)
_prototype =
{-# LINE 29 "./TypeChecking/Expressions.ag" #-}
Nothing
{-# LINE 3796 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 271, column 9)
_tpe =
{-# LINE 271 "./TypeChecking/Expressions.ag" #-}
do
let selType = getTypeAnnotation _selIannotatedTree
dependsOnRTpe [selType] $ do
f <- map snd <$> unwrapSetOfComposite selType
case length f of
0 -> Left [InternalError "no columns in scalar subquery?"]
1 -> Right $ head f
_ -> Right $ AnonymousRecordType f
{-# LINE 3808 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 281, column 9)
_backTree =
{-# LINE 281 "./TypeChecking/Expressions.ag" #-}
ScalarSubQuery ann_ _selIannotatedTree
{-# LINE 3813 "AstInternal.hs" #-}
-- "./TypeChecking/SelectLists.ag"(line 177, column 7)
_lhsOliftedColumnName =
{-# LINE 177 "./TypeChecking/SelectLists.ag" #-}
""
{-# LINE 3818 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
ScalarSubQuery ann_ _selIannotatedTree
{-# LINE 3823 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
ScalarSubQuery ann_ _selIoriginalTree
{-# LINE 3828 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 3833 "AstInternal.hs" #-}
-- copy rule (down)
_selOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 3838 "AstInternal.hs" #-}
-- copy rule (down)
_selOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 3843 "AstInternal.hs" #-}
( _selIannotatedTree,_selIlibUpdates,_selIoriginalTree) =
(sel_ _selOcat _selOlib )
in ( _lhsOannotatedTree,_lhsOliftedColumnName,_lhsOoriginalTree)))
sem_Expression_StringLit :: Annotation ->
String ->
String ->
T_Expression
sem_Expression_StringLit ann_ quote_ value_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: Expression
_prototype :: (Maybe FunctionPrototype)
_lhsOliftedColumnName :: String
_lhsOoriginalTree :: Expression
-- "./TypeChecking/Expressions.ag"(line 14, column 9)
_lhsOannotatedTree =
{-# LINE 14 "./TypeChecking/Expressions.ag" #-}
annTypesAndErrors _backTree
(tpeToT _tpe )
(getErrors _tpe )
$ fmap ((:[]) . FunctionPrototypeA) _prototype
{-# LINE 3865 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 29, column 9)
_prototype =
{-# LINE 29 "./TypeChecking/Expressions.ag" #-}
Nothing
{-# LINE 3870 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 39, column 18)
_tpe =
{-# LINE 39 "./TypeChecking/Expressions.ag" #-}
Right UnknownType
{-# LINE 3875 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 49, column 9)
_backTree =
{-# LINE 49 "./TypeChecking/Expressions.ag" #-}
StringLit ann_ quote_ value_
{-# LINE 3880 "AstInternal.hs" #-}
-- "./TypeChecking/SelectLists.ag"(line 177, column 7)
_lhsOliftedColumnName =
{-# LINE 177 "./TypeChecking/SelectLists.ag" #-}
""
{-# LINE 3885 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
StringLit ann_ quote_ value_
{-# LINE 3890 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
StringLit ann_ quote_ value_
{-# LINE 3895 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 3900 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOliftedColumnName,_lhsOoriginalTree)))
sem_Expression_WindowFn :: Annotation ->
T_Expression ->
T_ExpressionList ->
T_ExpressionList ->
T_Direction ->
T_FrameClause ->
T_Expression
sem_Expression_WindowFn ann_ fn_ partitionBy_ orderBy_ dir_ frm_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: Expression
_prototype :: (Maybe FunctionPrototype)
_lhsOoriginalTree :: Expression
_lhsOliftedColumnName :: String
_fnOcat :: Catalog
_fnOlib :: LocalIdentifierBindings
_partitionByOcat :: Catalog
_partitionByOlib :: LocalIdentifierBindings
_orderByOcat :: Catalog
_orderByOlib :: LocalIdentifierBindings
_dirOcat :: Catalog
_dirOlib :: LocalIdentifierBindings
_frmOcat :: Catalog
_frmOlib :: LocalIdentifierBindings
_fnIannotatedTree :: Expression
_fnIliftedColumnName :: String
_fnIoriginalTree :: Expression
_partitionByIannotatedTree :: ExpressionList
_partitionByIoriginalTree :: ExpressionList
_partitionByItypeList :: ([Type])
_orderByIannotatedTree :: ExpressionList
_orderByIoriginalTree :: ExpressionList
_orderByItypeList :: ([Type])
_dirIannotatedTree :: Direction
_dirIoriginalTree :: Direction
_frmIannotatedTree :: FrameClause
_frmIoriginalTree :: FrameClause
-- "./TypeChecking/Expressions.ag"(line 14, column 9)
_lhsOannotatedTree =
{-# LINE 14 "./TypeChecking/Expressions.ag" #-}
annTypesAndErrors _backTree
(tpeToT _tpe )
(getErrors _tpe )
$ fmap ((:[]) . FunctionPrototypeA) _prototype
{-# LINE 3946 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 29, column 9)
_prototype =
{-# LINE 29 "./TypeChecking/Expressions.ag" #-}
Nothing
{-# LINE 3951 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 87, column 9)
_tpe =
{-# LINE 87 "./TypeChecking/Expressions.ag" #-}
Right (getTypeAnnotation _fnIannotatedTree)
{-# LINE 3956 "AstInternal.hs" #-}
-- "./TypeChecking/Expressions.ag"(line 88, column 9)
_backTree =
{-# LINE 88 "./TypeChecking/Expressions.ag" #-}
WindowFn ann_
_fnIannotatedTree
_partitionByIannotatedTree
_orderByIannotatedTree
_dirIannotatedTree
_frmIannotatedTree
{-# LINE 3966 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
WindowFn ann_ _fnIannotatedTree _partitionByIannotatedTree _orderByIannotatedTree _dirIannotatedTree _frmIannotatedTree
{-# LINE 3971 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
WindowFn ann_ _fnIoriginalTree _partitionByIoriginalTree _orderByIoriginalTree _dirIoriginalTree _frmIoriginalTree
{-# LINE 3976 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 3981 "AstInternal.hs" #-}
-- copy rule (up)
_lhsOliftedColumnName =
{-# LINE 161 "./TypeChecking/SelectLists.ag" #-}
_fnIliftedColumnName
{-# LINE 3986 "AstInternal.hs" #-}
-- copy rule (down)
_fnOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 3991 "AstInternal.hs" #-}
-- copy rule (down)
_fnOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 3996 "AstInternal.hs" #-}
-- copy rule (down)
_partitionByOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 4001 "AstInternal.hs" #-}
-- copy rule (down)
_partitionByOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 4006 "AstInternal.hs" #-}
-- copy rule (down)
_orderByOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 4011 "AstInternal.hs" #-}
-- copy rule (down)
_orderByOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 4016 "AstInternal.hs" #-}
-- copy rule (down)
_dirOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 4021 "AstInternal.hs" #-}
-- copy rule (down)
_dirOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 4026 "AstInternal.hs" #-}
-- copy rule (down)
_frmOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 4031 "AstInternal.hs" #-}
-- copy rule (down)
_frmOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 4036 "AstInternal.hs" #-}
( _fnIannotatedTree,_fnIliftedColumnName,_fnIoriginalTree) =
(fn_ _fnOcat _fnOlib )
( _partitionByIannotatedTree,_partitionByIoriginalTree,_partitionByItypeList) =
(partitionBy_ _partitionByOcat _partitionByOlib )
( _orderByIannotatedTree,_orderByIoriginalTree,_orderByItypeList) =
(orderBy_ _orderByOcat _orderByOlib )
( _dirIannotatedTree,_dirIoriginalTree) =
(dir_ _dirOcat _dirOlib )
( _frmIannotatedTree,_frmIoriginalTree) =
(frm_ _frmOcat _frmOlib )
in ( _lhsOannotatedTree,_lhsOliftedColumnName,_lhsOoriginalTree)))
-- ExpressionDirectionPair -------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
originalTree : SELF
alternatives:
alternative Tuple:
child x1 : Expression
child x2 : Direction
visit 0:
local annotatedTree : _
local originalTree : _
-}
type ExpressionDirectionPair = ( (Expression),(Direction))
-- cata
sem_ExpressionDirectionPair :: ExpressionDirectionPair ->
T_ExpressionDirectionPair
sem_ExpressionDirectionPair ( x1,x2) =
(sem_ExpressionDirectionPair_Tuple (sem_Expression x1 ) (sem_Direction x2 ) )
-- semantic domain
type T_ExpressionDirectionPair = Catalog ->
LocalIdentifierBindings ->
( ExpressionDirectionPair,ExpressionDirectionPair)
data Inh_ExpressionDirectionPair = Inh_ExpressionDirectionPair {cat_Inh_ExpressionDirectionPair :: Catalog,lib_Inh_ExpressionDirectionPair :: LocalIdentifierBindings}
data Syn_ExpressionDirectionPair = Syn_ExpressionDirectionPair {annotatedTree_Syn_ExpressionDirectionPair :: ExpressionDirectionPair,originalTree_Syn_ExpressionDirectionPair :: ExpressionDirectionPair}
wrap_ExpressionDirectionPair :: T_ExpressionDirectionPair ->
Inh_ExpressionDirectionPair ->
Syn_ExpressionDirectionPair
wrap_ExpressionDirectionPair sem (Inh_ExpressionDirectionPair _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_ExpressionDirectionPair _lhsOannotatedTree _lhsOoriginalTree ))
sem_ExpressionDirectionPair_Tuple :: T_Expression ->
T_Direction ->
T_ExpressionDirectionPair
sem_ExpressionDirectionPair_Tuple x1_ x2_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: ExpressionDirectionPair
_lhsOoriginalTree :: ExpressionDirectionPair
_x1Ocat :: Catalog
_x1Olib :: LocalIdentifierBindings
_x2Ocat :: Catalog
_x2Olib :: LocalIdentifierBindings
_x1IannotatedTree :: Expression
_x1IliftedColumnName :: String
_x1IoriginalTree :: Expression
_x2IannotatedTree :: Direction
_x2IoriginalTree :: Direction
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
(_x1IannotatedTree,_x2IannotatedTree)
{-# LINE 4105 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
(_x1IoriginalTree,_x2IoriginalTree)
{-# LINE 4110 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 4115 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 4120 "AstInternal.hs" #-}
-- copy rule (down)
_x1Ocat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 4125 "AstInternal.hs" #-}
-- copy rule (down)
_x1Olib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 4130 "AstInternal.hs" #-}
-- copy rule (down)
_x2Ocat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 4135 "AstInternal.hs" #-}
-- copy rule (down)
_x2Olib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 4140 "AstInternal.hs" #-}
( _x1IannotatedTree,_x1IliftedColumnName,_x1IoriginalTree) =
(x1_ _x1Ocat _x1Olib )
( _x2IannotatedTree,_x2IoriginalTree) =
(x2_ _x2Ocat _x2Olib )
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
-- ExpressionDirectionPairList ---------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
originalTree : SELF
alternatives:
alternative Cons:
child hd : ExpressionDirectionPair
child tl : ExpressionDirectionPairList
visit 0:
local annotatedTree : _
local originalTree : _
alternative Nil:
visit 0:
local annotatedTree : _
local originalTree : _
-}
type ExpressionDirectionPairList = [(ExpressionDirectionPair)]
-- cata
sem_ExpressionDirectionPairList :: ExpressionDirectionPairList ->
T_ExpressionDirectionPairList
sem_ExpressionDirectionPairList list =
(Prelude.foldr sem_ExpressionDirectionPairList_Cons sem_ExpressionDirectionPairList_Nil (Prelude.map sem_ExpressionDirectionPair list) )
-- semantic domain
type T_ExpressionDirectionPairList = Catalog ->
LocalIdentifierBindings ->
( ExpressionDirectionPairList,ExpressionDirectionPairList)
data Inh_ExpressionDirectionPairList = Inh_ExpressionDirectionPairList {cat_Inh_ExpressionDirectionPairList :: Catalog,lib_Inh_ExpressionDirectionPairList :: LocalIdentifierBindings}
data Syn_ExpressionDirectionPairList = Syn_ExpressionDirectionPairList {annotatedTree_Syn_ExpressionDirectionPairList :: ExpressionDirectionPairList,originalTree_Syn_ExpressionDirectionPairList :: ExpressionDirectionPairList}
wrap_ExpressionDirectionPairList :: T_ExpressionDirectionPairList ->
Inh_ExpressionDirectionPairList ->
Syn_ExpressionDirectionPairList
wrap_ExpressionDirectionPairList sem (Inh_ExpressionDirectionPairList _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_ExpressionDirectionPairList _lhsOannotatedTree _lhsOoriginalTree ))
sem_ExpressionDirectionPairList_Cons :: T_ExpressionDirectionPair ->
T_ExpressionDirectionPairList ->
T_ExpressionDirectionPairList
sem_ExpressionDirectionPairList_Cons hd_ tl_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: ExpressionDirectionPairList
_lhsOoriginalTree :: ExpressionDirectionPairList
_hdOcat :: Catalog
_hdOlib :: LocalIdentifierBindings
_tlOcat :: Catalog
_tlOlib :: LocalIdentifierBindings
_hdIannotatedTree :: ExpressionDirectionPair
_hdIoriginalTree :: ExpressionDirectionPair
_tlIannotatedTree :: ExpressionDirectionPairList
_tlIoriginalTree :: ExpressionDirectionPairList
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
(:) _hdIannotatedTree _tlIannotatedTree
{-# LINE 4206 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
(:) _hdIoriginalTree _tlIoriginalTree
{-# LINE 4211 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 4216 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 4221 "AstInternal.hs" #-}
-- copy rule (down)
_hdOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 4226 "AstInternal.hs" #-}
-- copy rule (down)
_hdOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 4231 "AstInternal.hs" #-}
-- copy rule (down)
_tlOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 4236 "AstInternal.hs" #-}
-- copy rule (down)
_tlOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 4241 "AstInternal.hs" #-}
( _hdIannotatedTree,_hdIoriginalTree) =
(hd_ _hdOcat _hdOlib )
( _tlIannotatedTree,_tlIoriginalTree) =
(tl_ _tlOcat _tlOlib )
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
sem_ExpressionDirectionPairList_Nil :: T_ExpressionDirectionPairList
sem_ExpressionDirectionPairList_Nil =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: ExpressionDirectionPairList
_lhsOoriginalTree :: ExpressionDirectionPairList
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
[]
{-# LINE 4257 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
[]
{-# LINE 4262 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 4267 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 4272 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
-- ExpressionList ----------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
originalTree : SELF
typeList : [Type]
alternatives:
alternative Cons:
child hd : Expression
child tl : ExpressionList
visit 0:
local annotatedTree : _
local originalTree : _
alternative Nil:
visit 0:
local annotatedTree : _
local originalTree : _
-}
type ExpressionList = [(Expression)]
-- cata
sem_ExpressionList :: ExpressionList ->
T_ExpressionList
sem_ExpressionList list =
(Prelude.foldr sem_ExpressionList_Cons sem_ExpressionList_Nil (Prelude.map sem_Expression list) )
-- semantic domain
type T_ExpressionList = Catalog ->
LocalIdentifierBindings ->
( ExpressionList,ExpressionList,([Type]))
data Inh_ExpressionList = Inh_ExpressionList {cat_Inh_ExpressionList :: Catalog,lib_Inh_ExpressionList :: LocalIdentifierBindings}
data Syn_ExpressionList = Syn_ExpressionList {annotatedTree_Syn_ExpressionList :: ExpressionList,originalTree_Syn_ExpressionList :: ExpressionList,typeList_Syn_ExpressionList :: [Type]}
wrap_ExpressionList :: T_ExpressionList ->
Inh_ExpressionList ->
Syn_ExpressionList
wrap_ExpressionList sem (Inh_ExpressionList _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOtypeList) =
(sem _lhsIcat _lhsIlib )
in (Syn_ExpressionList _lhsOannotatedTree _lhsOoriginalTree _lhsOtypeList ))
sem_ExpressionList_Cons :: T_Expression ->
T_ExpressionList ->
T_ExpressionList
sem_ExpressionList_Cons hd_ tl_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOtypeList :: ([Type])
_lhsOannotatedTree :: ExpressionList
_lhsOoriginalTree :: ExpressionList
_hdOcat :: Catalog
_hdOlib :: LocalIdentifierBindings
_tlOcat :: Catalog
_tlOlib :: LocalIdentifierBindings
_hdIannotatedTree :: Expression
_hdIliftedColumnName :: String
_hdIoriginalTree :: Expression
_tlIannotatedTree :: ExpressionList
_tlIoriginalTree :: ExpressionList
_tlItypeList :: ([Type])
-- "./TypeChecking/Misc.ag"(line 52, column 12)
_lhsOtypeList =
{-# LINE 52 "./TypeChecking/Misc.ag" #-}
getTypeAnnotation _hdIannotatedTree : _tlItypeList
{-# LINE 4338 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
(:) _hdIannotatedTree _tlIannotatedTree
{-# LINE 4343 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
(:) _hdIoriginalTree _tlIoriginalTree
{-# LINE 4348 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 4353 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 4358 "AstInternal.hs" #-}
-- copy rule (down)
_hdOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 4363 "AstInternal.hs" #-}
-- copy rule (down)
_hdOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 4368 "AstInternal.hs" #-}
-- copy rule (down)
_tlOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 4373 "AstInternal.hs" #-}
-- copy rule (down)
_tlOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 4378 "AstInternal.hs" #-}
( _hdIannotatedTree,_hdIliftedColumnName,_hdIoriginalTree) =
(hd_ _hdOcat _hdOlib )
( _tlIannotatedTree,_tlIoriginalTree,_tlItypeList) =
(tl_ _tlOcat _tlOlib )
in ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOtypeList)))
sem_ExpressionList_Nil :: T_ExpressionList
sem_ExpressionList_Nil =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOtypeList :: ([Type])
_lhsOannotatedTree :: ExpressionList
_lhsOoriginalTree :: ExpressionList
-- "./TypeChecking/Misc.ag"(line 53, column 11)
_lhsOtypeList =
{-# LINE 53 "./TypeChecking/Misc.ag" #-}
[]
{-# LINE 4395 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
[]
{-# LINE 4400 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
[]
{-# LINE 4405 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 4410 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 4415 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOtypeList)))
-- ExpressionListList ------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
originalTree : SELF
typeListList : [[Type]]
alternatives:
alternative Cons:
child hd : ExpressionList
child tl : ExpressionListList
visit 0:
local annotatedTree : _
local originalTree : _
alternative Nil:
visit 0:
local annotatedTree : _
local originalTree : _
-}
type ExpressionListList = [(ExpressionList)]
-- cata
sem_ExpressionListList :: ExpressionListList ->
T_ExpressionListList
sem_ExpressionListList list =
(Prelude.foldr sem_ExpressionListList_Cons sem_ExpressionListList_Nil (Prelude.map sem_ExpressionList list) )
-- semantic domain
type T_ExpressionListList = Catalog ->
LocalIdentifierBindings ->
( ExpressionListList,ExpressionListList,([[Type]]))
data Inh_ExpressionListList = Inh_ExpressionListList {cat_Inh_ExpressionListList :: Catalog,lib_Inh_ExpressionListList :: LocalIdentifierBindings}
data Syn_ExpressionListList = Syn_ExpressionListList {annotatedTree_Syn_ExpressionListList :: ExpressionListList,originalTree_Syn_ExpressionListList :: ExpressionListList,typeListList_Syn_ExpressionListList :: [[Type]]}
wrap_ExpressionListList :: T_ExpressionListList ->
Inh_ExpressionListList ->
Syn_ExpressionListList
wrap_ExpressionListList sem (Inh_ExpressionListList _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOtypeListList) =
(sem _lhsIcat _lhsIlib )
in (Syn_ExpressionListList _lhsOannotatedTree _lhsOoriginalTree _lhsOtypeListList ))
sem_ExpressionListList_Cons :: T_ExpressionList ->
T_ExpressionListList ->
T_ExpressionListList
sem_ExpressionListList_Cons hd_ tl_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOtypeListList :: ([[Type]])
_lhsOannotatedTree :: ExpressionListList
_lhsOoriginalTree :: ExpressionListList
_hdOcat :: Catalog
_hdOlib :: LocalIdentifierBindings
_tlOcat :: Catalog
_tlOlib :: LocalIdentifierBindings
_hdIannotatedTree :: ExpressionList
_hdIoriginalTree :: ExpressionList
_hdItypeList :: ([Type])
_tlIannotatedTree :: ExpressionListList
_tlIoriginalTree :: ExpressionListList
_tlItypeListList :: ([[Type]])
-- "./TypeChecking/Misc.ag"(line 59, column 12)
_lhsOtypeListList =
{-# LINE 59 "./TypeChecking/Misc.ag" #-}
_hdItypeList : _tlItypeListList
{-# LINE 4481 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
(:) _hdIannotatedTree _tlIannotatedTree
{-# LINE 4486 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
(:) _hdIoriginalTree _tlIoriginalTree
{-# LINE 4491 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 4496 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 4501 "AstInternal.hs" #-}
-- copy rule (down)
_hdOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 4506 "AstInternal.hs" #-}
-- copy rule (down)
_hdOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 4511 "AstInternal.hs" #-}
-- copy rule (down)
_tlOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 4516 "AstInternal.hs" #-}
-- copy rule (down)
_tlOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 4521 "AstInternal.hs" #-}
( _hdIannotatedTree,_hdIoriginalTree,_hdItypeList) =
(hd_ _hdOcat _hdOlib )
( _tlIannotatedTree,_tlIoriginalTree,_tlItypeListList) =
(tl_ _tlOcat _tlOlib )
in ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOtypeListList)))
sem_ExpressionListList_Nil :: T_ExpressionListList
sem_ExpressionListList_Nil =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOtypeListList :: ([[Type]])
_lhsOannotatedTree :: ExpressionListList
_lhsOoriginalTree :: ExpressionListList
-- "./TypeChecking/Misc.ag"(line 60, column 11)
_lhsOtypeListList =
{-# LINE 60 "./TypeChecking/Misc.ag" #-}
[]
{-# LINE 4538 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
[]
{-# LINE 4543 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
[]
{-# LINE 4548 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 4553 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 4558 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOtypeListList)))
-- ExpressionListStatementListPair -----------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
originalTree : SELF
alternatives:
alternative Tuple:
child x1 : ExpressionList
child x2 : StatementList
visit 0:
local annotatedTree : _
local originalTree : _
-}
type ExpressionListStatementListPair = ( (ExpressionList),(StatementList))
-- cata
sem_ExpressionListStatementListPair :: ExpressionListStatementListPair ->
T_ExpressionListStatementListPair
sem_ExpressionListStatementListPair ( x1,x2) =
(sem_ExpressionListStatementListPair_Tuple (sem_ExpressionList x1 ) (sem_StatementList x2 ) )
-- semantic domain
type T_ExpressionListStatementListPair = Catalog ->
LocalIdentifierBindings ->
( ExpressionListStatementListPair,ExpressionListStatementListPair)
data Inh_ExpressionListStatementListPair = Inh_ExpressionListStatementListPair {cat_Inh_ExpressionListStatementListPair :: Catalog,lib_Inh_ExpressionListStatementListPair :: LocalIdentifierBindings}
data Syn_ExpressionListStatementListPair = Syn_ExpressionListStatementListPair {annotatedTree_Syn_ExpressionListStatementListPair :: ExpressionListStatementListPair,originalTree_Syn_ExpressionListStatementListPair :: ExpressionListStatementListPair}
wrap_ExpressionListStatementListPair :: T_ExpressionListStatementListPair ->
Inh_ExpressionListStatementListPair ->
Syn_ExpressionListStatementListPair
wrap_ExpressionListStatementListPair sem (Inh_ExpressionListStatementListPair _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_ExpressionListStatementListPair _lhsOannotatedTree _lhsOoriginalTree ))
sem_ExpressionListStatementListPair_Tuple :: T_ExpressionList ->
T_StatementList ->
T_ExpressionListStatementListPair
sem_ExpressionListStatementListPair_Tuple x1_ x2_ =
(\ _lhsIcat
_lhsIlib ->
(let _x2OcatUpdates :: ([CatalogUpdate])
_x2OlibUpdates :: ([LocalIdentifierBindingsUpdate])
_lhsOannotatedTree :: ExpressionListStatementListPair
_lhsOoriginalTree :: ExpressionListStatementListPair
_x1Ocat :: Catalog
_x1Olib :: LocalIdentifierBindings
_x2Ocat :: Catalog
_x2Olib :: LocalIdentifierBindings
_x1IannotatedTree :: ExpressionList
_x1IoriginalTree :: ExpressionList
_x1ItypeList :: ([Type])
_x2IannotatedTree :: StatementList
_x2IoriginalTree :: StatementList
_x2IproducedCat :: Catalog
_x2IproducedLib :: LocalIdentifierBindings
-- "./TypeChecking/Statements.ag"(line 94, column 9)
_x2OcatUpdates =
{-# LINE 94 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 4621 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 95, column 9)
_x2OlibUpdates =
{-# LINE 95 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 4626 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
(_x1IannotatedTree,_x2IannotatedTree)
{-# LINE 4631 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
(_x1IoriginalTree,_x2IoriginalTree)
{-# LINE 4636 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 4641 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 4646 "AstInternal.hs" #-}
-- copy rule (down)
_x1Ocat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 4651 "AstInternal.hs" #-}
-- copy rule (down)
_x1Olib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 4656 "AstInternal.hs" #-}
-- copy rule (down)
_x2Ocat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 4661 "AstInternal.hs" #-}
-- copy rule (down)
_x2Olib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 4666 "AstInternal.hs" #-}
( _x1IannotatedTree,_x1IoriginalTree,_x1ItypeList) =
(x1_ _x1Ocat _x1Olib )
( _x2IannotatedTree,_x2IoriginalTree,_x2IproducedCat,_x2IproducedLib) =
(x2_ _x2Ocat _x2OcatUpdates _x2Olib _x2OlibUpdates )
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
-- ExpressionListStatementListPairList -------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
originalTree : SELF
alternatives:
alternative Cons:
child hd : ExpressionListStatementListPair
child tl : ExpressionListStatementListPairList
visit 0:
local annotatedTree : _
local originalTree : _
alternative Nil:
visit 0:
local annotatedTree : _
local originalTree : _
-}
type ExpressionListStatementListPairList = [(ExpressionListStatementListPair)]
-- cata
sem_ExpressionListStatementListPairList :: ExpressionListStatementListPairList ->
T_ExpressionListStatementListPairList
sem_ExpressionListStatementListPairList list =
(Prelude.foldr sem_ExpressionListStatementListPairList_Cons sem_ExpressionListStatementListPairList_Nil (Prelude.map sem_ExpressionListStatementListPair list) )
-- semantic domain
type T_ExpressionListStatementListPairList = Catalog ->
LocalIdentifierBindings ->
( ExpressionListStatementListPairList,ExpressionListStatementListPairList)
data Inh_ExpressionListStatementListPairList = Inh_ExpressionListStatementListPairList {cat_Inh_ExpressionListStatementListPairList :: Catalog,lib_Inh_ExpressionListStatementListPairList :: LocalIdentifierBindings}
data Syn_ExpressionListStatementListPairList = Syn_ExpressionListStatementListPairList {annotatedTree_Syn_ExpressionListStatementListPairList :: ExpressionListStatementListPairList,originalTree_Syn_ExpressionListStatementListPairList :: ExpressionListStatementListPairList}
wrap_ExpressionListStatementListPairList :: T_ExpressionListStatementListPairList ->
Inh_ExpressionListStatementListPairList ->
Syn_ExpressionListStatementListPairList
wrap_ExpressionListStatementListPairList sem (Inh_ExpressionListStatementListPairList _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_ExpressionListStatementListPairList _lhsOannotatedTree _lhsOoriginalTree ))
sem_ExpressionListStatementListPairList_Cons :: T_ExpressionListStatementListPair ->
T_ExpressionListStatementListPairList ->
T_ExpressionListStatementListPairList
sem_ExpressionListStatementListPairList_Cons hd_ tl_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: ExpressionListStatementListPairList
_lhsOoriginalTree :: ExpressionListStatementListPairList
_hdOcat :: Catalog
_hdOlib :: LocalIdentifierBindings
_tlOcat :: Catalog
_tlOlib :: LocalIdentifierBindings
_hdIannotatedTree :: ExpressionListStatementListPair
_hdIoriginalTree :: ExpressionListStatementListPair
_tlIannotatedTree :: ExpressionListStatementListPairList
_tlIoriginalTree :: ExpressionListStatementListPairList
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
(:) _hdIannotatedTree _tlIannotatedTree
{-# LINE 4732 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
(:) _hdIoriginalTree _tlIoriginalTree
{-# LINE 4737 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 4742 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 4747 "AstInternal.hs" #-}
-- copy rule (down)
_hdOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 4752 "AstInternal.hs" #-}
-- copy rule (down)
_hdOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 4757 "AstInternal.hs" #-}
-- copy rule (down)
_tlOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 4762 "AstInternal.hs" #-}
-- copy rule (down)
_tlOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 4767 "AstInternal.hs" #-}
( _hdIannotatedTree,_hdIoriginalTree) =
(hd_ _hdOcat _hdOlib )
( _tlIannotatedTree,_tlIoriginalTree) =
(tl_ _tlOcat _tlOlib )
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
sem_ExpressionListStatementListPairList_Nil :: T_ExpressionListStatementListPairList
sem_ExpressionListStatementListPairList_Nil =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: ExpressionListStatementListPairList
_lhsOoriginalTree :: ExpressionListStatementListPairList
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
[]
{-# LINE 4783 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
[]
{-# LINE 4788 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 4793 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 4798 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
-- ExpressionRoot ----------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
originalTree : SELF
alternatives:
alternative ExpressionRoot:
child expr : Expression
visit 0:
local annotatedTree : _
local originalTree : _
-}
data ExpressionRoot = ExpressionRoot (Expression)
deriving ( Show)
-- cata
sem_ExpressionRoot :: ExpressionRoot ->
T_ExpressionRoot
sem_ExpressionRoot (ExpressionRoot _expr ) =
(sem_ExpressionRoot_ExpressionRoot (sem_Expression _expr ) )
-- semantic domain
type T_ExpressionRoot = Catalog ->
LocalIdentifierBindings ->
( ExpressionRoot,ExpressionRoot)
data Inh_ExpressionRoot = Inh_ExpressionRoot {cat_Inh_ExpressionRoot :: Catalog,lib_Inh_ExpressionRoot :: LocalIdentifierBindings}
data Syn_ExpressionRoot = Syn_ExpressionRoot {annotatedTree_Syn_ExpressionRoot :: ExpressionRoot,originalTree_Syn_ExpressionRoot :: ExpressionRoot}
wrap_ExpressionRoot :: T_ExpressionRoot ->
Inh_ExpressionRoot ->
Syn_ExpressionRoot
wrap_ExpressionRoot sem (Inh_ExpressionRoot _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_ExpressionRoot _lhsOannotatedTree _lhsOoriginalTree ))
sem_ExpressionRoot_ExpressionRoot :: T_Expression ->
T_ExpressionRoot
sem_ExpressionRoot_ExpressionRoot expr_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: ExpressionRoot
_lhsOoriginalTree :: ExpressionRoot
_exprOcat :: Catalog
_exprOlib :: LocalIdentifierBindings
_exprIannotatedTree :: Expression
_exprIliftedColumnName :: String
_exprIoriginalTree :: Expression
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
ExpressionRoot _exprIannotatedTree
{-# LINE 4852 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
ExpressionRoot _exprIoriginalTree
{-# LINE 4857 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 4862 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 4867 "AstInternal.hs" #-}
-- copy rule (down)
_exprOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 4872 "AstInternal.hs" #-}
-- copy rule (down)
_exprOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 4877 "AstInternal.hs" #-}
( _exprIannotatedTree,_exprIliftedColumnName,_exprIoriginalTree) =
(expr_ _exprOcat _exprOlib )
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
-- ExpressionStatementListPair ---------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
originalTree : SELF
alternatives:
alternative Tuple:
child x1 : Expression
child x2 : StatementList
visit 0:
local annotatedTree : _
local originalTree : _
-}
type ExpressionStatementListPair = ( (Expression),(StatementList))
-- cata
sem_ExpressionStatementListPair :: ExpressionStatementListPair ->
T_ExpressionStatementListPair
sem_ExpressionStatementListPair ( x1,x2) =
(sem_ExpressionStatementListPair_Tuple (sem_Expression x1 ) (sem_StatementList x2 ) )
-- semantic domain
type T_ExpressionStatementListPair = Catalog ->
LocalIdentifierBindings ->
( ExpressionStatementListPair,ExpressionStatementListPair)
data Inh_ExpressionStatementListPair = Inh_ExpressionStatementListPair {cat_Inh_ExpressionStatementListPair :: Catalog,lib_Inh_ExpressionStatementListPair :: LocalIdentifierBindings}
data Syn_ExpressionStatementListPair = Syn_ExpressionStatementListPair {annotatedTree_Syn_ExpressionStatementListPair :: ExpressionStatementListPair,originalTree_Syn_ExpressionStatementListPair :: ExpressionStatementListPair}
wrap_ExpressionStatementListPair :: T_ExpressionStatementListPair ->
Inh_ExpressionStatementListPair ->
Syn_ExpressionStatementListPair
wrap_ExpressionStatementListPair sem (Inh_ExpressionStatementListPair _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_ExpressionStatementListPair _lhsOannotatedTree _lhsOoriginalTree ))
sem_ExpressionStatementListPair_Tuple :: T_Expression ->
T_StatementList ->
T_ExpressionStatementListPair
sem_ExpressionStatementListPair_Tuple x1_ x2_ =
(\ _lhsIcat
_lhsIlib ->
(let _x2OcatUpdates :: ([CatalogUpdate])
_x2OlibUpdates :: ([LocalIdentifierBindingsUpdate])
_lhsOannotatedTree :: ExpressionStatementListPair
_lhsOoriginalTree :: ExpressionStatementListPair
_x1Ocat :: Catalog
_x1Olib :: LocalIdentifierBindings
_x2Ocat :: Catalog
_x2Olib :: LocalIdentifierBindings
_x1IannotatedTree :: Expression
_x1IliftedColumnName :: String
_x1IoriginalTree :: Expression
_x2IannotatedTree :: StatementList
_x2IoriginalTree :: StatementList
_x2IproducedCat :: Catalog
_x2IproducedLib :: LocalIdentifierBindings
-- "./TypeChecking/Statements.ag"(line 98, column 9)
_x2OcatUpdates =
{-# LINE 98 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 4942 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 99, column 9)
_x2OlibUpdates =
{-# LINE 99 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 4947 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
(_x1IannotatedTree,_x2IannotatedTree)
{-# LINE 4952 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
(_x1IoriginalTree,_x2IoriginalTree)
{-# LINE 4957 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 4962 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 4967 "AstInternal.hs" #-}
-- copy rule (down)
_x1Ocat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 4972 "AstInternal.hs" #-}
-- copy rule (down)
_x1Olib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 4977 "AstInternal.hs" #-}
-- copy rule (down)
_x2Ocat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 4982 "AstInternal.hs" #-}
-- copy rule (down)
_x2Olib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 4987 "AstInternal.hs" #-}
( _x1IannotatedTree,_x1IliftedColumnName,_x1IoriginalTree) =
(x1_ _x1Ocat _x1Olib )
( _x2IannotatedTree,_x2IoriginalTree,_x2IproducedCat,_x2IproducedLib) =
(x2_ _x2Ocat _x2OcatUpdates _x2Olib _x2OlibUpdates )
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
-- ExpressionStatementListPairList -----------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
originalTree : SELF
alternatives:
alternative Cons:
child hd : ExpressionStatementListPair
child tl : ExpressionStatementListPairList
visit 0:
local annotatedTree : _
local originalTree : _
alternative Nil:
visit 0:
local annotatedTree : _
local originalTree : _
-}
type ExpressionStatementListPairList = [(ExpressionStatementListPair)]
-- cata
sem_ExpressionStatementListPairList :: ExpressionStatementListPairList ->
T_ExpressionStatementListPairList
sem_ExpressionStatementListPairList list =
(Prelude.foldr sem_ExpressionStatementListPairList_Cons sem_ExpressionStatementListPairList_Nil (Prelude.map sem_ExpressionStatementListPair list) )
-- semantic domain
type T_ExpressionStatementListPairList = Catalog ->
LocalIdentifierBindings ->
( ExpressionStatementListPairList,ExpressionStatementListPairList)
data Inh_ExpressionStatementListPairList = Inh_ExpressionStatementListPairList {cat_Inh_ExpressionStatementListPairList :: Catalog,lib_Inh_ExpressionStatementListPairList :: LocalIdentifierBindings}
data Syn_ExpressionStatementListPairList = Syn_ExpressionStatementListPairList {annotatedTree_Syn_ExpressionStatementListPairList :: ExpressionStatementListPairList,originalTree_Syn_ExpressionStatementListPairList :: ExpressionStatementListPairList}
wrap_ExpressionStatementListPairList :: T_ExpressionStatementListPairList ->
Inh_ExpressionStatementListPairList ->
Syn_ExpressionStatementListPairList
wrap_ExpressionStatementListPairList sem (Inh_ExpressionStatementListPairList _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_ExpressionStatementListPairList _lhsOannotatedTree _lhsOoriginalTree ))
sem_ExpressionStatementListPairList_Cons :: T_ExpressionStatementListPair ->
T_ExpressionStatementListPairList ->
T_ExpressionStatementListPairList
sem_ExpressionStatementListPairList_Cons hd_ tl_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: ExpressionStatementListPairList
_lhsOoriginalTree :: ExpressionStatementListPairList
_hdOcat :: Catalog
_hdOlib :: LocalIdentifierBindings
_tlOcat :: Catalog
_tlOlib :: LocalIdentifierBindings
_hdIannotatedTree :: ExpressionStatementListPair
_hdIoriginalTree :: ExpressionStatementListPair
_tlIannotatedTree :: ExpressionStatementListPairList
_tlIoriginalTree :: ExpressionStatementListPairList
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
(:) _hdIannotatedTree _tlIannotatedTree
{-# LINE 5053 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
(:) _hdIoriginalTree _tlIoriginalTree
{-# LINE 5058 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 5063 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 5068 "AstInternal.hs" #-}
-- copy rule (down)
_hdOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 5073 "AstInternal.hs" #-}
-- copy rule (down)
_hdOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 5078 "AstInternal.hs" #-}
-- copy rule (down)
_tlOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 5083 "AstInternal.hs" #-}
-- copy rule (down)
_tlOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 5088 "AstInternal.hs" #-}
( _hdIannotatedTree,_hdIoriginalTree) =
(hd_ _hdOcat _hdOlib )
( _tlIannotatedTree,_tlIoriginalTree) =
(tl_ _tlOcat _tlOlib )
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
sem_ExpressionStatementListPairList_Nil :: T_ExpressionStatementListPairList
sem_ExpressionStatementListPairList_Nil =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: ExpressionStatementListPairList
_lhsOoriginalTree :: ExpressionStatementListPairList
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
[]
{-# LINE 5104 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
[]
{-# LINE 5109 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 5114 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 5119 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
-- FnBody ------------------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
originalTree : SELF
alternatives:
alternative PlpgsqlFnBody:
child ann : {Annotation}
child vars : VarDefList
child sts : StatementList
visit 0:
local annotatedTree : _
local originalTree : _
alternative SqlFnBody:
child ann : {Annotation}
child sts : StatementList
visit 0:
local annotatedTree : _
local originalTree : _
-}
data FnBody = PlpgsqlFnBody (Annotation) (VarDefList) (StatementList)
| SqlFnBody (Annotation) (StatementList)
deriving ( Data,Eq,Show,Typeable)
-- cata
sem_FnBody :: FnBody ->
T_FnBody
sem_FnBody (PlpgsqlFnBody _ann _vars _sts ) =
(sem_FnBody_PlpgsqlFnBody _ann (sem_VarDefList _vars ) (sem_StatementList _sts ) )
sem_FnBody (SqlFnBody _ann _sts ) =
(sem_FnBody_SqlFnBody _ann (sem_StatementList _sts ) )
-- semantic domain
type T_FnBody = Catalog ->
LocalIdentifierBindings ->
( FnBody,FnBody)
data Inh_FnBody = Inh_FnBody {cat_Inh_FnBody :: Catalog,lib_Inh_FnBody :: LocalIdentifierBindings}
data Syn_FnBody = Syn_FnBody {annotatedTree_Syn_FnBody :: FnBody,originalTree_Syn_FnBody :: FnBody}
wrap_FnBody :: T_FnBody ->
Inh_FnBody ->
Syn_FnBody
wrap_FnBody sem (Inh_FnBody _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_FnBody _lhsOannotatedTree _lhsOoriginalTree ))
sem_FnBody_PlpgsqlFnBody :: Annotation ->
T_VarDefList ->
T_StatementList ->
T_FnBody
sem_FnBody_PlpgsqlFnBody ann_ vars_ sts_ =
(\ _lhsIcat
_lhsIlib ->
(let _stsOcatUpdates :: ([CatalogUpdate])
_stsOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_stsOlib :: LocalIdentifierBindings
_lhsOannotatedTree :: FnBody
_lhsOoriginalTree :: FnBody
_varsOcat :: Catalog
_varsOlib :: LocalIdentifierBindings
_stsOcat :: Catalog
_varsIannotatedTree :: VarDefList
_varsIdefs :: ([(String,Type)])
_varsIoriginalTree :: VarDefList
_stsIannotatedTree :: StatementList
_stsIoriginalTree :: StatementList
_stsIproducedCat :: Catalog
_stsIproducedLib :: LocalIdentifierBindings
-- "./TypeChecking/Statements.ag"(line 102, column 9)
_stsOcatUpdates =
{-# LINE 102 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 5194 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 103, column 9)
_stsOlibUpdates =
{-# LINE 103 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 5199 "AstInternal.hs" #-}
-- "./TypeChecking/CreateFunction.ag"(line 121, column 9)
_stsOlib =
{-# LINE 121 "./TypeChecking/CreateFunction.ag" #-}
fromRight _lhsIlib $
updateBindings _lhsIlib _lhsIcat
[LibStackIDs [("", _varsIdefs)]]
{-# LINE 5206 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
PlpgsqlFnBody ann_ _varsIannotatedTree _stsIannotatedTree
{-# LINE 5211 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
PlpgsqlFnBody ann_ _varsIoriginalTree _stsIoriginalTree
{-# LINE 5216 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 5221 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 5226 "AstInternal.hs" #-}
-- copy rule (down)
_varsOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 5231 "AstInternal.hs" #-}
-- copy rule (down)
_varsOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 5236 "AstInternal.hs" #-}
-- copy rule (down)
_stsOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 5241 "AstInternal.hs" #-}
( _varsIannotatedTree,_varsIdefs,_varsIoriginalTree) =
(vars_ _varsOcat _varsOlib )
( _stsIannotatedTree,_stsIoriginalTree,_stsIproducedCat,_stsIproducedLib) =
(sts_ _stsOcat _stsOcatUpdates _stsOlib _stsOlibUpdates )
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
sem_FnBody_SqlFnBody :: Annotation ->
T_StatementList ->
T_FnBody
sem_FnBody_SqlFnBody ann_ sts_ =
(\ _lhsIcat
_lhsIlib ->
(let _stsOcatUpdates :: ([CatalogUpdate])
_stsOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_lhsOannotatedTree :: FnBody
_lhsOoriginalTree :: FnBody
_stsOcat :: Catalog
_stsOlib :: LocalIdentifierBindings
_stsIannotatedTree :: StatementList
_stsIoriginalTree :: StatementList
_stsIproducedCat :: Catalog
_stsIproducedLib :: LocalIdentifierBindings
-- "./TypeChecking/Statements.ag"(line 102, column 9)
_stsOcatUpdates =
{-# LINE 102 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 5267 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 103, column 9)
_stsOlibUpdates =
{-# LINE 103 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 5272 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
SqlFnBody ann_ _stsIannotatedTree
{-# LINE 5277 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
SqlFnBody ann_ _stsIoriginalTree
{-# LINE 5282 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 5287 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 5292 "AstInternal.hs" #-}
-- copy rule (down)
_stsOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 5297 "AstInternal.hs" #-}
-- copy rule (down)
_stsOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 5302 "AstInternal.hs" #-}
( _stsIannotatedTree,_stsIoriginalTree,_stsIproducedCat,_stsIproducedLib) =
(sts_ _stsOcat _stsOcatUpdates _stsOlib _stsOlibUpdates )
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
-- FrameClause -------------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
originalTree : SELF
alternatives:
alternative FrameRowsUnboundedPreceding:
visit 0:
local annotatedTree : _
local originalTree : _
alternative FrameUnboundedFull:
visit 0:
local annotatedTree : _
local originalTree : _
alternative FrameUnboundedPreceding:
visit 0:
local annotatedTree : _
local originalTree : _
-}
data FrameClause = FrameRowsUnboundedPreceding
| FrameUnboundedFull
| FrameUnboundedPreceding
deriving ( Data,Eq,Show,Typeable)
-- cata
sem_FrameClause :: FrameClause ->
T_FrameClause
sem_FrameClause (FrameRowsUnboundedPreceding ) =
(sem_FrameClause_FrameRowsUnboundedPreceding )
sem_FrameClause (FrameUnboundedFull ) =
(sem_FrameClause_FrameUnboundedFull )
sem_FrameClause (FrameUnboundedPreceding ) =
(sem_FrameClause_FrameUnboundedPreceding )
-- semantic domain
type T_FrameClause = Catalog ->
LocalIdentifierBindings ->
( FrameClause,FrameClause)
data Inh_FrameClause = Inh_FrameClause {cat_Inh_FrameClause :: Catalog,lib_Inh_FrameClause :: LocalIdentifierBindings}
data Syn_FrameClause = Syn_FrameClause {annotatedTree_Syn_FrameClause :: FrameClause,originalTree_Syn_FrameClause :: FrameClause}
wrap_FrameClause :: T_FrameClause ->
Inh_FrameClause ->
Syn_FrameClause
wrap_FrameClause sem (Inh_FrameClause _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_FrameClause _lhsOannotatedTree _lhsOoriginalTree ))
sem_FrameClause_FrameRowsUnboundedPreceding :: T_FrameClause
sem_FrameClause_FrameRowsUnboundedPreceding =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: FrameClause
_lhsOoriginalTree :: FrameClause
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
FrameRowsUnboundedPreceding
{-# LINE 5365 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
FrameRowsUnboundedPreceding
{-# LINE 5370 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 5375 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 5380 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
sem_FrameClause_FrameUnboundedFull :: T_FrameClause
sem_FrameClause_FrameUnboundedFull =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: FrameClause
_lhsOoriginalTree :: FrameClause
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
FrameUnboundedFull
{-# LINE 5392 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
FrameUnboundedFull
{-# LINE 5397 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 5402 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 5407 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
sem_FrameClause_FrameUnboundedPreceding :: T_FrameClause
sem_FrameClause_FrameUnboundedPreceding =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: FrameClause
_lhsOoriginalTree :: FrameClause
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
FrameUnboundedPreceding
{-# LINE 5419 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
FrameUnboundedPreceding
{-# LINE 5424 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 5429 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 5434 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
-- IfExists ----------------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
originalTree : SELF
alternatives:
alternative IfExists:
visit 0:
local annotatedTree : _
local originalTree : _
alternative Require:
visit 0:
local annotatedTree : _
local originalTree : _
-}
data IfExists = IfExists
| Require
deriving ( Data,Eq,Show,Typeable)
-- cata
sem_IfExists :: IfExists ->
T_IfExists
sem_IfExists (IfExists ) =
(sem_IfExists_IfExists )
sem_IfExists (Require ) =
(sem_IfExists_Require )
-- semantic domain
type T_IfExists = Catalog ->
LocalIdentifierBindings ->
( IfExists,IfExists)
data Inh_IfExists = Inh_IfExists {cat_Inh_IfExists :: Catalog,lib_Inh_IfExists :: LocalIdentifierBindings}
data Syn_IfExists = Syn_IfExists {annotatedTree_Syn_IfExists :: IfExists,originalTree_Syn_IfExists :: IfExists}
wrap_IfExists :: T_IfExists ->
Inh_IfExists ->
Syn_IfExists
wrap_IfExists sem (Inh_IfExists _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_IfExists _lhsOannotatedTree _lhsOoriginalTree ))
sem_IfExists_IfExists :: T_IfExists
sem_IfExists_IfExists =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: IfExists
_lhsOoriginalTree :: IfExists
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
IfExists
{-# LINE 5488 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
IfExists
{-# LINE 5493 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 5498 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 5503 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
sem_IfExists_Require :: T_IfExists
sem_IfExists_Require =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: IfExists
_lhsOoriginalTree :: IfExists
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
Require
{-# LINE 5515 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
Require
{-# LINE 5520 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 5525 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 5530 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
-- InList ------------------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
listType : Either [TypeError] Type
originalTree : SELF
alternatives:
alternative InList:
child ann : {Annotation}
child exprs : ExpressionList
visit 0:
local annotatedTree : _
local originalTree : _
alternative InSelect:
child ann : {Annotation}
child sel : SelectExpression
visit 0:
local annotatedTree : _
local originalTree : _
-}
data InList = InList (Annotation) (ExpressionList)
| InSelect (Annotation) (SelectExpression)
deriving ( Data,Eq,Show,Typeable)
-- cata
sem_InList :: InList ->
T_InList
sem_InList (InList _ann _exprs ) =
(sem_InList_InList _ann (sem_ExpressionList _exprs ) )
sem_InList (InSelect _ann _sel ) =
(sem_InList_InSelect _ann (sem_SelectExpression _sel ) )
-- semantic domain
type T_InList = Catalog ->
LocalIdentifierBindings ->
( InList,(Either [TypeError] Type),InList)
data Inh_InList = Inh_InList {cat_Inh_InList :: Catalog,lib_Inh_InList :: LocalIdentifierBindings}
data Syn_InList = Syn_InList {annotatedTree_Syn_InList :: InList,listType_Syn_InList :: Either [TypeError] Type,originalTree_Syn_InList :: InList}
wrap_InList :: T_InList ->
Inh_InList ->
Syn_InList
wrap_InList sem (Inh_InList _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOlistType,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_InList _lhsOannotatedTree _lhsOlistType _lhsOoriginalTree ))
sem_InList_InList :: Annotation ->
T_ExpressionList ->
T_InList
sem_InList_InList ann_ exprs_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOlistType :: (Either [TypeError] Type)
_lhsOannotatedTree :: InList
_lhsOoriginalTree :: InList
_exprsOcat :: Catalog
_exprsOlib :: LocalIdentifierBindings
_exprsIannotatedTree :: ExpressionList
_exprsIoriginalTree :: ExpressionList
_exprsItypeList :: ([Type])
-- "./TypeChecking/Expressions.ag"(line 305, column 9)
_lhsOlistType =
{-# LINE 305 "./TypeChecking/Expressions.ag" #-}
resolveResultSetType _lhsIcat _exprsItypeList
{-# LINE 5597 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
InList ann_ _exprsIannotatedTree
{-# LINE 5602 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
InList ann_ _exprsIoriginalTree
{-# LINE 5607 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 5612 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 5617 "AstInternal.hs" #-}
-- copy rule (down)
_exprsOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 5622 "AstInternal.hs" #-}
-- copy rule (down)
_exprsOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 5627 "AstInternal.hs" #-}
( _exprsIannotatedTree,_exprsIoriginalTree,_exprsItypeList) =
(exprs_ _exprsOcat _exprsOlib )
in ( _lhsOannotatedTree,_lhsOlistType,_lhsOoriginalTree)))
sem_InList_InSelect :: Annotation ->
T_SelectExpression ->
T_InList
sem_InList_InSelect ann_ sel_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOlistType :: (Either [TypeError] Type)
_lhsOannotatedTree :: InList
_lhsOoriginalTree :: InList
_selOcat :: Catalog
_selOlib :: LocalIdentifierBindings
_selIannotatedTree :: SelectExpression
_selIlibUpdates :: ([LocalIdentifierBindingsUpdate])
_selIoriginalTree :: SelectExpression
-- "./TypeChecking/Expressions.ag"(line 307, column 9)
_lhsOlistType =
{-# LINE 307 "./TypeChecking/Expressions.ag" #-}
do
attrs <- map snd <$> (unwrapSetOfComposite $
getTypeAnnotation _selIannotatedTree)
typ <- case length attrs of
0 -> Left [InternalError
"got subquery with no columns? in inselect"]
1 -> Right $ head attrs
_ -> Right $ AnonymousRecordType attrs
dependsOnRTpe attrs $ Right typ
{-# LINE 5657 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
InSelect ann_ _selIannotatedTree
{-# LINE 5662 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
InSelect ann_ _selIoriginalTree
{-# LINE 5667 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 5672 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 5677 "AstInternal.hs" #-}
-- copy rule (down)
_selOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 5682 "AstInternal.hs" #-}
-- copy rule (down)
_selOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 5687 "AstInternal.hs" #-}
( _selIannotatedTree,_selIlibUpdates,_selIoriginalTree) =
(sel_ _selOcat _selOlib )
in ( _lhsOannotatedTree,_lhsOlistType,_lhsOoriginalTree)))
-- JoinExpression ----------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
originalTree : SELF
alternatives:
alternative JoinOn:
child ann : {Annotation}
child expression : Expression
visit 0:
local annotatedTree : _
local originalTree : _
alternative JoinUsing:
child ann : {Annotation}
child stringList : StringList
visit 0:
local annotatedTree : _
local originalTree : _
-}
data JoinExpression = JoinOn (Annotation) (Expression)
| JoinUsing (Annotation) (StringList)
deriving ( Data,Eq,Show,Typeable)
-- cata
sem_JoinExpression :: JoinExpression ->
T_JoinExpression
sem_JoinExpression (JoinOn _ann _expression ) =
(sem_JoinExpression_JoinOn _ann (sem_Expression _expression ) )
sem_JoinExpression (JoinUsing _ann _stringList ) =
(sem_JoinExpression_JoinUsing _ann (sem_StringList _stringList ) )
-- semantic domain
type T_JoinExpression = Catalog ->
LocalIdentifierBindings ->
( JoinExpression,JoinExpression)
data Inh_JoinExpression = Inh_JoinExpression {cat_Inh_JoinExpression :: Catalog,lib_Inh_JoinExpression :: LocalIdentifierBindings}
data Syn_JoinExpression = Syn_JoinExpression {annotatedTree_Syn_JoinExpression :: JoinExpression,originalTree_Syn_JoinExpression :: JoinExpression}
wrap_JoinExpression :: T_JoinExpression ->
Inh_JoinExpression ->
Syn_JoinExpression
wrap_JoinExpression sem (Inh_JoinExpression _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_JoinExpression _lhsOannotatedTree _lhsOoriginalTree ))
sem_JoinExpression_JoinOn :: Annotation ->
T_Expression ->
T_JoinExpression
sem_JoinExpression_JoinOn ann_ expression_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: JoinExpression
_lhsOoriginalTree :: JoinExpression
_expressionOcat :: Catalog
_expressionOlib :: LocalIdentifierBindings
_expressionIannotatedTree :: Expression
_expressionIliftedColumnName :: String
_expressionIoriginalTree :: Expression
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
JoinOn ann_ _expressionIannotatedTree
{-# LINE 5754 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
JoinOn ann_ _expressionIoriginalTree
{-# LINE 5759 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 5764 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 5769 "AstInternal.hs" #-}
-- copy rule (down)
_expressionOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 5774 "AstInternal.hs" #-}
-- copy rule (down)
_expressionOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 5779 "AstInternal.hs" #-}
( _expressionIannotatedTree,_expressionIliftedColumnName,_expressionIoriginalTree) =
(expression_ _expressionOcat _expressionOlib )
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
sem_JoinExpression_JoinUsing :: Annotation ->
T_StringList ->
T_JoinExpression
sem_JoinExpression_JoinUsing ann_ stringList_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: JoinExpression
_lhsOoriginalTree :: JoinExpression
_stringListOcat :: Catalog
_stringListOlib :: LocalIdentifierBindings
_stringListIannotatedTree :: StringList
_stringListIoriginalTree :: StringList
_stringListIstrings :: ([String])
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
JoinUsing ann_ _stringListIannotatedTree
{-# LINE 5800 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
JoinUsing ann_ _stringListIoriginalTree
{-# LINE 5805 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 5810 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 5815 "AstInternal.hs" #-}
-- copy rule (down)
_stringListOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 5820 "AstInternal.hs" #-}
-- copy rule (down)
_stringListOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 5825 "AstInternal.hs" #-}
( _stringListIannotatedTree,_stringListIoriginalTree,_stringListIstrings) =
(stringList_ _stringListOcat _stringListOlib )
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
-- JoinType ----------------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
originalTree : SELF
alternatives:
alternative Cross:
visit 0:
local annotatedTree : _
local originalTree : _
alternative FullOuter:
visit 0:
local annotatedTree : _
local originalTree : _
alternative Inner:
visit 0:
local annotatedTree : _
local originalTree : _
alternative LeftOuter:
visit 0:
local annotatedTree : _
local originalTree : _
alternative RightOuter:
visit 0:
local annotatedTree : _
local originalTree : _
-}
data JoinType = Cross
| FullOuter
| Inner
| LeftOuter
| RightOuter
deriving ( Data,Eq,Show,Typeable)
-- cata
sem_JoinType :: JoinType ->
T_JoinType
sem_JoinType (Cross ) =
(sem_JoinType_Cross )
sem_JoinType (FullOuter ) =
(sem_JoinType_FullOuter )
sem_JoinType (Inner ) =
(sem_JoinType_Inner )
sem_JoinType (LeftOuter ) =
(sem_JoinType_LeftOuter )
sem_JoinType (RightOuter ) =
(sem_JoinType_RightOuter )
-- semantic domain
type T_JoinType = Catalog ->
LocalIdentifierBindings ->
( JoinType,JoinType)
data Inh_JoinType = Inh_JoinType {cat_Inh_JoinType :: Catalog,lib_Inh_JoinType :: LocalIdentifierBindings}
data Syn_JoinType = Syn_JoinType {annotatedTree_Syn_JoinType :: JoinType,originalTree_Syn_JoinType :: JoinType}
wrap_JoinType :: T_JoinType ->
Inh_JoinType ->
Syn_JoinType
wrap_JoinType sem (Inh_JoinType _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_JoinType _lhsOannotatedTree _lhsOoriginalTree ))
sem_JoinType_Cross :: T_JoinType
sem_JoinType_Cross =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: JoinType
_lhsOoriginalTree :: JoinType
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
Cross
{-# LINE 5902 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
Cross
{-# LINE 5907 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 5912 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 5917 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
sem_JoinType_FullOuter :: T_JoinType
sem_JoinType_FullOuter =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: JoinType
_lhsOoriginalTree :: JoinType
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
FullOuter
{-# LINE 5929 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
FullOuter
{-# LINE 5934 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 5939 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 5944 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
sem_JoinType_Inner :: T_JoinType
sem_JoinType_Inner =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: JoinType
_lhsOoriginalTree :: JoinType
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
Inner
{-# LINE 5956 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
Inner
{-# LINE 5961 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 5966 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 5971 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
sem_JoinType_LeftOuter :: T_JoinType
sem_JoinType_LeftOuter =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: JoinType
_lhsOoriginalTree :: JoinType
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
LeftOuter
{-# LINE 5983 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
LeftOuter
{-# LINE 5988 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 5993 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 5998 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
sem_JoinType_RightOuter :: T_JoinType
sem_JoinType_RightOuter =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: JoinType
_lhsOoriginalTree :: JoinType
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
RightOuter
{-# LINE 6010 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
RightOuter
{-# LINE 6015 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 6020 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 6025 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
-- Language ----------------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
originalTree : SELF
alternatives:
alternative Plpgsql:
visit 0:
local annotatedTree : _
local originalTree : _
alternative Sql:
visit 0:
local annotatedTree : _
local originalTree : _
-}
data Language = Plpgsql
| Sql
deriving ( Data,Eq,Show,Typeable)
-- cata
sem_Language :: Language ->
T_Language
sem_Language (Plpgsql ) =
(sem_Language_Plpgsql )
sem_Language (Sql ) =
(sem_Language_Sql )
-- semantic domain
type T_Language = Catalog ->
LocalIdentifierBindings ->
( Language,Language)
data Inh_Language = Inh_Language {cat_Inh_Language :: Catalog,lib_Inh_Language :: LocalIdentifierBindings}
data Syn_Language = Syn_Language {annotatedTree_Syn_Language :: Language,originalTree_Syn_Language :: Language}
wrap_Language :: T_Language ->
Inh_Language ->
Syn_Language
wrap_Language sem (Inh_Language _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_Language _lhsOannotatedTree _lhsOoriginalTree ))
sem_Language_Plpgsql :: T_Language
sem_Language_Plpgsql =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: Language
_lhsOoriginalTree :: Language
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
Plpgsql
{-# LINE 6079 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
Plpgsql
{-# LINE 6084 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 6089 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 6094 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
sem_Language_Sql :: T_Language
sem_Language_Sql =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: Language
_lhsOoriginalTree :: Language
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
Sql
{-# LINE 6106 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
Sql
{-# LINE 6111 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 6116 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 6121 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
-- LiftFlavour -------------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
originalTree : SELF
alternatives:
alternative LiftAll:
visit 0:
local annotatedTree : _
local originalTree : _
alternative LiftAny:
visit 0:
local annotatedTree : _
local originalTree : _
-}
data LiftFlavour = LiftAll
| LiftAny
deriving ( Data,Eq,Show,Typeable)
-- cata
sem_LiftFlavour :: LiftFlavour ->
T_LiftFlavour
sem_LiftFlavour (LiftAll ) =
(sem_LiftFlavour_LiftAll )
sem_LiftFlavour (LiftAny ) =
(sem_LiftFlavour_LiftAny )
-- semantic domain
type T_LiftFlavour = Catalog ->
LocalIdentifierBindings ->
( LiftFlavour,LiftFlavour)
data Inh_LiftFlavour = Inh_LiftFlavour {cat_Inh_LiftFlavour :: Catalog,lib_Inh_LiftFlavour :: LocalIdentifierBindings}
data Syn_LiftFlavour = Syn_LiftFlavour {annotatedTree_Syn_LiftFlavour :: LiftFlavour,originalTree_Syn_LiftFlavour :: LiftFlavour}
wrap_LiftFlavour :: T_LiftFlavour ->
Inh_LiftFlavour ->
Syn_LiftFlavour
wrap_LiftFlavour sem (Inh_LiftFlavour _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_LiftFlavour _lhsOannotatedTree _lhsOoriginalTree ))
sem_LiftFlavour_LiftAll :: T_LiftFlavour
sem_LiftFlavour_LiftAll =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: LiftFlavour
_lhsOoriginalTree :: LiftFlavour
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
LiftAll
{-# LINE 6175 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
LiftAll
{-# LINE 6180 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 6185 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 6190 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
sem_LiftFlavour_LiftAny :: T_LiftFlavour
sem_LiftFlavour_LiftAny =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: LiftFlavour
_lhsOoriginalTree :: LiftFlavour
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
LiftAny
{-# LINE 6202 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
LiftAny
{-# LINE 6207 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 6212 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 6217 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
-- MaybeBoolExpression -----------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
originalTree : SELF
alternatives:
alternative Just:
child just : Expression
visit 0:
local annotatedTree : _
local originalTree : _
alternative Nothing:
visit 0:
local annotatedTree : _
local originalTree : _
-}
type MaybeBoolExpression = (Maybe (Expression))
-- cata
sem_MaybeBoolExpression :: MaybeBoolExpression ->
T_MaybeBoolExpression
sem_MaybeBoolExpression (Prelude.Just x ) =
(sem_MaybeBoolExpression_Just (sem_Expression x ) )
sem_MaybeBoolExpression Prelude.Nothing =
sem_MaybeBoolExpression_Nothing
-- semantic domain
type T_MaybeBoolExpression = Catalog ->
LocalIdentifierBindings ->
( MaybeBoolExpression,MaybeBoolExpression)
data Inh_MaybeBoolExpression = Inh_MaybeBoolExpression {cat_Inh_MaybeBoolExpression :: Catalog,lib_Inh_MaybeBoolExpression :: LocalIdentifierBindings}
data Syn_MaybeBoolExpression = Syn_MaybeBoolExpression {annotatedTree_Syn_MaybeBoolExpression :: MaybeBoolExpression,originalTree_Syn_MaybeBoolExpression :: MaybeBoolExpression}
wrap_MaybeBoolExpression :: T_MaybeBoolExpression ->
Inh_MaybeBoolExpression ->
Syn_MaybeBoolExpression
wrap_MaybeBoolExpression sem (Inh_MaybeBoolExpression _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_MaybeBoolExpression _lhsOannotatedTree _lhsOoriginalTree ))
sem_MaybeBoolExpression_Just :: T_Expression ->
T_MaybeBoolExpression
sem_MaybeBoolExpression_Just just_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: MaybeBoolExpression
_lhsOoriginalTree :: MaybeBoolExpression
_justOcat :: Catalog
_justOlib :: LocalIdentifierBindings
_justIannotatedTree :: Expression
_justIliftedColumnName :: String
_justIoriginalTree :: Expression
-- "./TypeChecking/Misc.ag"(line 74, column 9)
_lhsOannotatedTree =
{-# LINE 74 "./TypeChecking/Misc.ag" #-}
if getTypeAnnotation _justIannotatedTree `notElem` [typeBool, TypeCheckFailed]
then Just $ updateAnnotation ((TypeErrorA ExpressionMustBeBool) :)
_justIannotatedTree
else Just $ _justIannotatedTree
{-# LINE 6279 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
Just _justIannotatedTree
{-# LINE 6284 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
Just _justIoriginalTree
{-# LINE 6289 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 6294 "AstInternal.hs" #-}
-- copy rule (down)
_justOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 6299 "AstInternal.hs" #-}
-- copy rule (down)
_justOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 6304 "AstInternal.hs" #-}
( _justIannotatedTree,_justIliftedColumnName,_justIoriginalTree) =
(just_ _justOcat _justOlib )
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
sem_MaybeBoolExpression_Nothing :: T_MaybeBoolExpression
sem_MaybeBoolExpression_Nothing =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: MaybeBoolExpression
_lhsOoriginalTree :: MaybeBoolExpression
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
Nothing
{-# LINE 6318 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
Nothing
{-# LINE 6323 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 6328 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 6333 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
-- MaybeExpression ---------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
originalTree : SELF
alternatives:
alternative Just:
child just : Expression
visit 0:
local annotatedTree : _
local originalTree : _
alternative Nothing:
visit 0:
local annotatedTree : _
local originalTree : _
-}
type MaybeExpression = (Maybe (Expression))
-- cata
sem_MaybeExpression :: MaybeExpression ->
T_MaybeExpression
sem_MaybeExpression (Prelude.Just x ) =
(sem_MaybeExpression_Just (sem_Expression x ) )
sem_MaybeExpression Prelude.Nothing =
sem_MaybeExpression_Nothing
-- semantic domain
type T_MaybeExpression = Catalog ->
LocalIdentifierBindings ->
( MaybeExpression,MaybeExpression)
data Inh_MaybeExpression = Inh_MaybeExpression {cat_Inh_MaybeExpression :: Catalog,lib_Inh_MaybeExpression :: LocalIdentifierBindings}
data Syn_MaybeExpression = Syn_MaybeExpression {annotatedTree_Syn_MaybeExpression :: MaybeExpression,originalTree_Syn_MaybeExpression :: MaybeExpression}
wrap_MaybeExpression :: T_MaybeExpression ->
Inh_MaybeExpression ->
Syn_MaybeExpression
wrap_MaybeExpression sem (Inh_MaybeExpression _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_MaybeExpression _lhsOannotatedTree _lhsOoriginalTree ))
sem_MaybeExpression_Just :: T_Expression ->
T_MaybeExpression
sem_MaybeExpression_Just just_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: MaybeExpression
_lhsOoriginalTree :: MaybeExpression
_justOcat :: Catalog
_justOlib :: LocalIdentifierBindings
_justIannotatedTree :: Expression
_justIliftedColumnName :: String
_justIoriginalTree :: Expression
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
Just _justIannotatedTree
{-# LINE 6392 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
Just _justIoriginalTree
{-# LINE 6397 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 6402 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 6407 "AstInternal.hs" #-}
-- copy rule (down)
_justOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 6412 "AstInternal.hs" #-}
-- copy rule (down)
_justOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 6417 "AstInternal.hs" #-}
( _justIannotatedTree,_justIliftedColumnName,_justIoriginalTree) =
(just_ _justOcat _justOlib )
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
sem_MaybeExpression_Nothing :: T_MaybeExpression
sem_MaybeExpression_Nothing =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: MaybeExpression
_lhsOoriginalTree :: MaybeExpression
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
Nothing
{-# LINE 6431 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
Nothing
{-# LINE 6436 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 6441 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 6446 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
-- MaybeSelectList ---------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
listType : Maybe [(String,Type)]
originalTree : SELF
alternatives:
alternative Just:
child just : SelectList
visit 0:
local annotatedTree : _
local originalTree : _
alternative Nothing:
visit 0:
local annotatedTree : _
local originalTree : _
-}
type MaybeSelectList = (Maybe (SelectList))
-- cata
sem_MaybeSelectList :: MaybeSelectList ->
T_MaybeSelectList
sem_MaybeSelectList (Prelude.Just x ) =
(sem_MaybeSelectList_Just (sem_SelectList x ) )
sem_MaybeSelectList Prelude.Nothing =
sem_MaybeSelectList_Nothing
-- semantic domain
type T_MaybeSelectList = Catalog ->
LocalIdentifierBindings ->
( MaybeSelectList,(Maybe [(String,Type)]),MaybeSelectList)
data Inh_MaybeSelectList = Inh_MaybeSelectList {cat_Inh_MaybeSelectList :: Catalog,lib_Inh_MaybeSelectList :: LocalIdentifierBindings}
data Syn_MaybeSelectList = Syn_MaybeSelectList {annotatedTree_Syn_MaybeSelectList :: MaybeSelectList,listType_Syn_MaybeSelectList :: Maybe [(String,Type)],originalTree_Syn_MaybeSelectList :: MaybeSelectList}
wrap_MaybeSelectList :: T_MaybeSelectList ->
Inh_MaybeSelectList ->
Syn_MaybeSelectList
wrap_MaybeSelectList sem (Inh_MaybeSelectList _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOlistType,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_MaybeSelectList _lhsOannotatedTree _lhsOlistType _lhsOoriginalTree ))
sem_MaybeSelectList_Just :: T_SelectList ->
T_MaybeSelectList
sem_MaybeSelectList_Just just_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOlistType :: (Maybe [(String,Type)])
_lhsOannotatedTree :: MaybeSelectList
_lhsOoriginalTree :: MaybeSelectList
_justOcat :: Catalog
_justOlib :: LocalIdentifierBindings
_justIannotatedTree :: SelectList
_justIlibUpdates :: ([LocalIdentifierBindingsUpdate])
_justIlistType :: ([(String,Type)])
_justIoriginalTree :: SelectList
-- "./TypeChecking/SelectLists.ag"(line 25, column 12)
_lhsOlistType =
{-# LINE 25 "./TypeChecking/SelectLists.ag" #-}
Just _justIlistType
{-# LINE 6508 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
Just _justIannotatedTree
{-# LINE 6513 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
Just _justIoriginalTree
{-# LINE 6518 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 6523 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 6528 "AstInternal.hs" #-}
-- copy rule (down)
_justOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 6533 "AstInternal.hs" #-}
-- copy rule (down)
_justOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 6538 "AstInternal.hs" #-}
( _justIannotatedTree,_justIlibUpdates,_justIlistType,_justIoriginalTree) =
(just_ _justOcat _justOlib )
in ( _lhsOannotatedTree,_lhsOlistType,_lhsOoriginalTree)))
sem_MaybeSelectList_Nothing :: T_MaybeSelectList
sem_MaybeSelectList_Nothing =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOlistType :: (Maybe [(String,Type)])
_lhsOannotatedTree :: MaybeSelectList
_lhsOoriginalTree :: MaybeSelectList
-- "./TypeChecking/SelectLists.ag"(line 26, column 15)
_lhsOlistType =
{-# LINE 26 "./TypeChecking/SelectLists.ag" #-}
Nothing
{-# LINE 6553 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
Nothing
{-# LINE 6558 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
Nothing
{-# LINE 6563 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 6568 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 6573 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOlistType,_lhsOoriginalTree)))
-- Natural -----------------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
originalTree : SELF
alternatives:
alternative Natural:
visit 0:
local annotatedTree : _
local originalTree : _
alternative Unnatural:
visit 0:
local annotatedTree : _
local originalTree : _
-}
data Natural = Natural
| Unnatural
deriving ( Data,Eq,Show,Typeable)
-- cata
sem_Natural :: Natural ->
T_Natural
sem_Natural (Natural ) =
(sem_Natural_Natural )
sem_Natural (Unnatural ) =
(sem_Natural_Unnatural )
-- semantic domain
type T_Natural = Catalog ->
LocalIdentifierBindings ->
( Natural,Natural)
data Inh_Natural = Inh_Natural {cat_Inh_Natural :: Catalog,lib_Inh_Natural :: LocalIdentifierBindings}
data Syn_Natural = Syn_Natural {annotatedTree_Syn_Natural :: Natural,originalTree_Syn_Natural :: Natural}
wrap_Natural :: T_Natural ->
Inh_Natural ->
Syn_Natural
wrap_Natural sem (Inh_Natural _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_Natural _lhsOannotatedTree _lhsOoriginalTree ))
sem_Natural_Natural :: T_Natural
sem_Natural_Natural =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: Natural
_lhsOoriginalTree :: Natural
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
Natural
{-# LINE 6627 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
Natural
{-# LINE 6632 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 6637 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 6642 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
sem_Natural_Unnatural :: T_Natural
sem_Natural_Unnatural =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: Natural
_lhsOoriginalTree :: Natural
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
Unnatural
{-# LINE 6654 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
Unnatural
{-# LINE 6659 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 6664 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 6669 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
-- OnExpr ------------------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
originalTree : SELF
alternatives:
alternative Just:
child just : JoinExpression
visit 0:
local annotatedTree : _
local originalTree : _
alternative Nothing:
visit 0:
local annotatedTree : _
local originalTree : _
-}
type OnExpr = (Maybe (JoinExpression))
-- cata
sem_OnExpr :: OnExpr ->
T_OnExpr
sem_OnExpr (Prelude.Just x ) =
(sem_OnExpr_Just (sem_JoinExpression x ) )
sem_OnExpr Prelude.Nothing =
sem_OnExpr_Nothing
-- semantic domain
type T_OnExpr = Catalog ->
LocalIdentifierBindings ->
( OnExpr,OnExpr)
data Inh_OnExpr = Inh_OnExpr {cat_Inh_OnExpr :: Catalog,lib_Inh_OnExpr :: LocalIdentifierBindings}
data Syn_OnExpr = Syn_OnExpr {annotatedTree_Syn_OnExpr :: OnExpr,originalTree_Syn_OnExpr :: OnExpr}
wrap_OnExpr :: T_OnExpr ->
Inh_OnExpr ->
Syn_OnExpr
wrap_OnExpr sem (Inh_OnExpr _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_OnExpr _lhsOannotatedTree _lhsOoriginalTree ))
sem_OnExpr_Just :: T_JoinExpression ->
T_OnExpr
sem_OnExpr_Just just_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: OnExpr
_lhsOoriginalTree :: OnExpr
_justOcat :: Catalog
_justOlib :: LocalIdentifierBindings
_justIannotatedTree :: JoinExpression
_justIoriginalTree :: JoinExpression
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
Just _justIannotatedTree
{-# LINE 6727 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
Just _justIoriginalTree
{-# LINE 6732 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 6737 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 6742 "AstInternal.hs" #-}
-- copy rule (down)
_justOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 6747 "AstInternal.hs" #-}
-- copy rule (down)
_justOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 6752 "AstInternal.hs" #-}
( _justIannotatedTree,_justIoriginalTree) =
(just_ _justOcat _justOlib )
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
sem_OnExpr_Nothing :: T_OnExpr
sem_OnExpr_Nothing =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: OnExpr
_lhsOoriginalTree :: OnExpr
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
Nothing
{-# LINE 6766 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
Nothing
{-# LINE 6771 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 6776 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 6781 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
-- ParamDef ----------------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
namedType : Type
originalTree : SELF
paramName : String
alternatives:
alternative ParamDef:
child ann : {Annotation}
child name : {String}
child typ : TypeName
visit 0:
local annotatedTree : _
local originalTree : _
alternative ParamDefTp:
child ann : {Annotation}
child typ : TypeName
visit 0:
local annotatedTree : _
local originalTree : _
-}
data ParamDef = ParamDef (Annotation) (String) (TypeName)
| ParamDefTp (Annotation) (TypeName)
deriving ( Data,Eq,Show,Typeable)
-- cata
sem_ParamDef :: ParamDef ->
T_ParamDef
sem_ParamDef (ParamDef _ann _name _typ ) =
(sem_ParamDef_ParamDef _ann _name (sem_TypeName _typ ) )
sem_ParamDef (ParamDefTp _ann _typ ) =
(sem_ParamDef_ParamDefTp _ann (sem_TypeName _typ ) )
-- semantic domain
type T_ParamDef = Catalog ->
LocalIdentifierBindings ->
( ParamDef,Type,ParamDef,String)
data Inh_ParamDef = Inh_ParamDef {cat_Inh_ParamDef :: Catalog,lib_Inh_ParamDef :: LocalIdentifierBindings}
data Syn_ParamDef = Syn_ParamDef {annotatedTree_Syn_ParamDef :: ParamDef,namedType_Syn_ParamDef :: Type,originalTree_Syn_ParamDef :: ParamDef,paramName_Syn_ParamDef :: String}
wrap_ParamDef :: T_ParamDef ->
Inh_ParamDef ->
Syn_ParamDef
wrap_ParamDef sem (Inh_ParamDef _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOnamedType,_lhsOoriginalTree,_lhsOparamName) =
(sem _lhsIcat _lhsIlib )
in (Syn_ParamDef _lhsOannotatedTree _lhsOnamedType _lhsOoriginalTree _lhsOparamName ))
sem_ParamDef_ParamDef :: Annotation ->
String ->
T_TypeName ->
T_ParamDef
sem_ParamDef_ParamDef ann_ name_ typ_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOnamedType :: Type
_lhsOparamName :: String
_lhsOannotatedTree :: ParamDef
_lhsOoriginalTree :: ParamDef
_typOcat :: Catalog
_typOlib :: LocalIdentifierBindings
_typIannotatedTree :: TypeName
_typInamedType :: Type
_typIoriginalTree :: TypeName
-- "./TypeChecking/CreateFunction.ag"(line 56, column 9)
_lhsOnamedType =
{-# LINE 56 "./TypeChecking/CreateFunction.ag" #-}
_typInamedType
{-# LINE 6852 "AstInternal.hs" #-}
-- "./TypeChecking/CreateFunction.ag"(line 58, column 9)
_lhsOparamName =
{-# LINE 58 "./TypeChecking/CreateFunction.ag" #-}
name_
{-# LINE 6857 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
ParamDef ann_ name_ _typIannotatedTree
{-# LINE 6862 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
ParamDef ann_ name_ _typIoriginalTree
{-# LINE 6867 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 6872 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 6877 "AstInternal.hs" #-}
-- copy rule (down)
_typOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 6882 "AstInternal.hs" #-}
-- copy rule (down)
_typOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 6887 "AstInternal.hs" #-}
( _typIannotatedTree,_typInamedType,_typIoriginalTree) =
(typ_ _typOcat _typOlib )
in ( _lhsOannotatedTree,_lhsOnamedType,_lhsOoriginalTree,_lhsOparamName)))
sem_ParamDef_ParamDefTp :: Annotation ->
T_TypeName ->
T_ParamDef
sem_ParamDef_ParamDefTp ann_ typ_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOnamedType :: Type
_lhsOparamName :: String
_lhsOannotatedTree :: ParamDef
_lhsOoriginalTree :: ParamDef
_typOcat :: Catalog
_typOlib :: LocalIdentifierBindings
_typIannotatedTree :: TypeName
_typInamedType :: Type
_typIoriginalTree :: TypeName
-- "./TypeChecking/CreateFunction.ag"(line 56, column 9)
_lhsOnamedType =
{-# LINE 56 "./TypeChecking/CreateFunction.ag" #-}
_typInamedType
{-# LINE 6910 "AstInternal.hs" #-}
-- "./TypeChecking/CreateFunction.ag"(line 60, column 9)
_lhsOparamName =
{-# LINE 60 "./TypeChecking/CreateFunction.ag" #-}
""
{-# LINE 6915 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
ParamDefTp ann_ _typIannotatedTree
{-# LINE 6920 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
ParamDefTp ann_ _typIoriginalTree
{-# LINE 6925 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 6930 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 6935 "AstInternal.hs" #-}
-- copy rule (down)
_typOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 6940 "AstInternal.hs" #-}
-- copy rule (down)
_typOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 6945 "AstInternal.hs" #-}
( _typIannotatedTree,_typInamedType,_typIoriginalTree) =
(typ_ _typOcat _typOlib )
in ( _lhsOannotatedTree,_lhsOnamedType,_lhsOoriginalTree,_lhsOparamName)))
-- ParamDefList ------------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
originalTree : SELF
params : [(String, Type)]
alternatives:
alternative Cons:
child hd : ParamDef
child tl : ParamDefList
visit 0:
local annotatedTree : _
local originalTree : _
alternative Nil:
visit 0:
local annotatedTree : _
local originalTree : _
-}
type ParamDefList = [(ParamDef)]
-- cata
sem_ParamDefList :: ParamDefList ->
T_ParamDefList
sem_ParamDefList list =
(Prelude.foldr sem_ParamDefList_Cons sem_ParamDefList_Nil (Prelude.map sem_ParamDef list) )
-- semantic domain
type T_ParamDefList = Catalog ->
LocalIdentifierBindings ->
( ParamDefList,ParamDefList,([(String, Type)]))
data Inh_ParamDefList = Inh_ParamDefList {cat_Inh_ParamDefList :: Catalog,lib_Inh_ParamDefList :: LocalIdentifierBindings}
data Syn_ParamDefList = Syn_ParamDefList {annotatedTree_Syn_ParamDefList :: ParamDefList,originalTree_Syn_ParamDefList :: ParamDefList,params_Syn_ParamDefList :: [(String, Type)]}
wrap_ParamDefList :: T_ParamDefList ->
Inh_ParamDefList ->
Syn_ParamDefList
wrap_ParamDefList sem (Inh_ParamDefList _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOparams) =
(sem _lhsIcat _lhsIlib )
in (Syn_ParamDefList _lhsOannotatedTree _lhsOoriginalTree _lhsOparams ))
sem_ParamDefList_Cons :: T_ParamDef ->
T_ParamDefList ->
T_ParamDefList
sem_ParamDefList_Cons hd_ tl_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOparams :: ([(String, Type)])
_lhsOannotatedTree :: ParamDefList
_lhsOoriginalTree :: ParamDefList
_hdOcat :: Catalog
_hdOlib :: LocalIdentifierBindings
_tlOcat :: Catalog
_tlOlib :: LocalIdentifierBindings
_hdIannotatedTree :: ParamDef
_hdInamedType :: Type
_hdIoriginalTree :: ParamDef
_hdIparamName :: String
_tlIannotatedTree :: ParamDefList
_tlIoriginalTree :: ParamDefList
_tlIparams :: ([(String, Type)])
-- "./TypeChecking/CreateFunction.ag"(line 64, column 13)
_lhsOparams =
{-# LINE 64 "./TypeChecking/CreateFunction.ag" #-}
((_hdIparamName, _hdInamedType) : _tlIparams)
{-# LINE 7014 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
(:) _hdIannotatedTree _tlIannotatedTree
{-# LINE 7019 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
(:) _hdIoriginalTree _tlIoriginalTree
{-# LINE 7024 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 7029 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 7034 "AstInternal.hs" #-}
-- copy rule (down)
_hdOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 7039 "AstInternal.hs" #-}
-- copy rule (down)
_hdOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 7044 "AstInternal.hs" #-}
-- copy rule (down)
_tlOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 7049 "AstInternal.hs" #-}
-- copy rule (down)
_tlOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 7054 "AstInternal.hs" #-}
( _hdIannotatedTree,_hdInamedType,_hdIoriginalTree,_hdIparamName) =
(hd_ _hdOcat _hdOlib )
( _tlIannotatedTree,_tlIoriginalTree,_tlIparams) =
(tl_ _tlOcat _tlOlib )
in ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOparams)))
sem_ParamDefList_Nil :: T_ParamDefList
sem_ParamDefList_Nil =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOparams :: ([(String, Type)])
_lhsOannotatedTree :: ParamDefList
_lhsOoriginalTree :: ParamDefList
-- "./TypeChecking/CreateFunction.ag"(line 63, column 12)
_lhsOparams =
{-# LINE 63 "./TypeChecking/CreateFunction.ag" #-}
[]
{-# LINE 7071 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
[]
{-# LINE 7076 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
[]
{-# LINE 7081 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 7086 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 7091 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOparams)))
-- RaiseType ---------------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
originalTree : SELF
alternatives:
alternative RError:
visit 0:
local annotatedTree : _
local originalTree : _
alternative RException:
visit 0:
local annotatedTree : _
local originalTree : _
alternative RNotice:
visit 0:
local annotatedTree : _
local originalTree : _
-}
data RaiseType = RError
| RException
| RNotice
deriving ( Data,Eq,Show,Typeable)
-- cata
sem_RaiseType :: RaiseType ->
T_RaiseType
sem_RaiseType (RError ) =
(sem_RaiseType_RError )
sem_RaiseType (RException ) =
(sem_RaiseType_RException )
sem_RaiseType (RNotice ) =
(sem_RaiseType_RNotice )
-- semantic domain
type T_RaiseType = Catalog ->
LocalIdentifierBindings ->
( RaiseType,RaiseType)
data Inh_RaiseType = Inh_RaiseType {cat_Inh_RaiseType :: Catalog,lib_Inh_RaiseType :: LocalIdentifierBindings}
data Syn_RaiseType = Syn_RaiseType {annotatedTree_Syn_RaiseType :: RaiseType,originalTree_Syn_RaiseType :: RaiseType}
wrap_RaiseType :: T_RaiseType ->
Inh_RaiseType ->
Syn_RaiseType
wrap_RaiseType sem (Inh_RaiseType _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_RaiseType _lhsOannotatedTree _lhsOoriginalTree ))
sem_RaiseType_RError :: T_RaiseType
sem_RaiseType_RError =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: RaiseType
_lhsOoriginalTree :: RaiseType
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
RError
{-# LINE 7152 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
RError
{-# LINE 7157 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 7162 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 7167 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
sem_RaiseType_RException :: T_RaiseType
sem_RaiseType_RException =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: RaiseType
_lhsOoriginalTree :: RaiseType
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
RException
{-# LINE 7179 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
RException
{-# LINE 7184 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 7189 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 7194 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
sem_RaiseType_RNotice :: T_RaiseType
sem_RaiseType_RNotice =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: RaiseType
_lhsOoriginalTree :: RaiseType
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
RNotice
{-# LINE 7206 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
RNotice
{-# LINE 7211 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 7216 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 7221 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
-- RestartIdentity ---------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
originalTree : SELF
alternatives:
alternative ContinueIdentity:
visit 0:
local annotatedTree : _
local originalTree : _
alternative RestartIdentity:
visit 0:
local annotatedTree : _
local originalTree : _
-}
data RestartIdentity = ContinueIdentity
| RestartIdentity
deriving ( Data,Eq,Show,Typeable)
-- cata
sem_RestartIdentity :: RestartIdentity ->
T_RestartIdentity
sem_RestartIdentity (ContinueIdentity ) =
(sem_RestartIdentity_ContinueIdentity )
sem_RestartIdentity (RestartIdentity ) =
(sem_RestartIdentity_RestartIdentity )
-- semantic domain
type T_RestartIdentity = Catalog ->
LocalIdentifierBindings ->
( RestartIdentity,RestartIdentity)
data Inh_RestartIdentity = Inh_RestartIdentity {cat_Inh_RestartIdentity :: Catalog,lib_Inh_RestartIdentity :: LocalIdentifierBindings}
data Syn_RestartIdentity = Syn_RestartIdentity {annotatedTree_Syn_RestartIdentity :: RestartIdentity,originalTree_Syn_RestartIdentity :: RestartIdentity}
wrap_RestartIdentity :: T_RestartIdentity ->
Inh_RestartIdentity ->
Syn_RestartIdentity
wrap_RestartIdentity sem (Inh_RestartIdentity _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_RestartIdentity _lhsOannotatedTree _lhsOoriginalTree ))
sem_RestartIdentity_ContinueIdentity :: T_RestartIdentity
sem_RestartIdentity_ContinueIdentity =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: RestartIdentity
_lhsOoriginalTree :: RestartIdentity
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
ContinueIdentity
{-# LINE 7275 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
ContinueIdentity
{-# LINE 7280 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 7285 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 7290 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
sem_RestartIdentity_RestartIdentity :: T_RestartIdentity
sem_RestartIdentity_RestartIdentity =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: RestartIdentity
_lhsOoriginalTree :: RestartIdentity
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
RestartIdentity
{-# LINE 7302 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
RestartIdentity
{-# LINE 7307 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 7312 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 7317 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
-- Root --------------------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
originalTree : SELF
producedCat : Catalog
producedLib : LocalIdentifierBindings
alternatives:
alternative Root:
child statements : StatementList
visit 0:
local annotatedTree : _
local originalTree : _
-}
data Root = Root (StatementList)
deriving ( Show)
-- cata
sem_Root :: Root ->
T_Root
sem_Root (Root _statements ) =
(sem_Root_Root (sem_StatementList _statements ) )
-- semantic domain
type T_Root = Catalog ->
LocalIdentifierBindings ->
( Root,Root,Catalog,LocalIdentifierBindings)
data Inh_Root = Inh_Root {cat_Inh_Root :: Catalog,lib_Inh_Root :: LocalIdentifierBindings}
data Syn_Root = Syn_Root {annotatedTree_Syn_Root :: Root,originalTree_Syn_Root :: Root,producedCat_Syn_Root :: Catalog,producedLib_Syn_Root :: LocalIdentifierBindings}
wrap_Root :: T_Root ->
Inh_Root ->
Syn_Root
wrap_Root sem (Inh_Root _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOproducedCat,_lhsOproducedLib) =
(sem _lhsIcat _lhsIlib )
in (Syn_Root _lhsOannotatedTree _lhsOoriginalTree _lhsOproducedCat _lhsOproducedLib ))
sem_Root_Root :: T_StatementList ->
T_Root
sem_Root_Root statements_ =
(\ _lhsIcat
_lhsIlib ->
(let _statementsOcatUpdates :: ([CatalogUpdate])
_statementsOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_lhsOannotatedTree :: Root
_lhsOoriginalTree :: Root
_lhsOproducedCat :: Catalog
_lhsOproducedLib :: LocalIdentifierBindings
_statementsOcat :: Catalog
_statementsOlib :: LocalIdentifierBindings
_statementsIannotatedTree :: StatementList
_statementsIoriginalTree :: StatementList
_statementsIproducedCat :: Catalog
_statementsIproducedLib :: LocalIdentifierBindings
-- "./TypeChecking/Statements.ag"(line 80, column 12)
_statementsOcatUpdates =
{-# LINE 80 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 7378 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 81, column 12)
_statementsOlibUpdates =
{-# LINE 81 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 7383 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
Root _statementsIannotatedTree
{-# LINE 7388 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
Root _statementsIoriginalTree
{-# LINE 7393 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 7398 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 7403 "AstInternal.hs" #-}
-- copy rule (up)
_lhsOproducedCat =
{-# LINE 27 "./TypeChecking/Statements.ag" #-}
_statementsIproducedCat
{-# LINE 7408 "AstInternal.hs" #-}
-- copy rule (up)
_lhsOproducedLib =
{-# LINE 28 "./TypeChecking/Statements.ag" #-}
_statementsIproducedLib
{-# LINE 7413 "AstInternal.hs" #-}
-- copy rule (down)
_statementsOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 7418 "AstInternal.hs" #-}
-- copy rule (down)
_statementsOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 7423 "AstInternal.hs" #-}
( _statementsIannotatedTree,_statementsIoriginalTree,_statementsIproducedCat,_statementsIproducedLib) =
(statements_ _statementsOcat _statementsOcatUpdates _statementsOlib _statementsOlibUpdates )
in ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOproducedCat,_lhsOproducedLib)))
-- RowConstraint -----------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
originalTree : SELF
alternatives:
alternative NotNullConstraint:
child ann : {Annotation}
child name : {String}
visit 0:
local annotatedTree : _
local originalTree : _
alternative NullConstraint:
child ann : {Annotation}
child name : {String}
visit 0:
local annotatedTree : _
local originalTree : _
alternative RowCheckConstraint:
child ann : {Annotation}
child name : {String}
child expression : Expression
visit 0:
local annotatedTree : _
local originalTree : _
alternative RowPrimaryKeyConstraint:
child ann : {Annotation}
child name : {String}
visit 0:
local annotatedTree : _
local originalTree : _
alternative RowReferenceConstraint:
child ann : {Annotation}
child name : {String}
child table : {String}
child att : {Maybe String}
child onUpdate : Cascade
child onDelete : Cascade
visit 0:
local annotatedTree : _
local originalTree : _
alternative RowUniqueConstraint:
child ann : {Annotation}
child name : {String}
visit 0:
local annotatedTree : _
local originalTree : _
-}
data RowConstraint = NotNullConstraint (Annotation) (String)
| NullConstraint (Annotation) (String)
| RowCheckConstraint (Annotation) (String) (Expression)
| RowPrimaryKeyConstraint (Annotation) (String)
| RowReferenceConstraint (Annotation) (String) (String) (Maybe String) (Cascade) (Cascade)
| RowUniqueConstraint (Annotation) (String)
deriving ( Data,Eq,Show,Typeable)
-- cata
sem_RowConstraint :: RowConstraint ->
T_RowConstraint
sem_RowConstraint (NotNullConstraint _ann _name ) =
(sem_RowConstraint_NotNullConstraint _ann _name )
sem_RowConstraint (NullConstraint _ann _name ) =
(sem_RowConstraint_NullConstraint _ann _name )
sem_RowConstraint (RowCheckConstraint _ann _name _expression ) =
(sem_RowConstraint_RowCheckConstraint _ann _name (sem_Expression _expression ) )
sem_RowConstraint (RowPrimaryKeyConstraint _ann _name ) =
(sem_RowConstraint_RowPrimaryKeyConstraint _ann _name )
sem_RowConstraint (RowReferenceConstraint _ann _name _table _att _onUpdate _onDelete ) =
(sem_RowConstraint_RowReferenceConstraint _ann _name _table _att (sem_Cascade _onUpdate ) (sem_Cascade _onDelete ) )
sem_RowConstraint (RowUniqueConstraint _ann _name ) =
(sem_RowConstraint_RowUniqueConstraint _ann _name )
-- semantic domain
type T_RowConstraint = Catalog ->
LocalIdentifierBindings ->
( RowConstraint,RowConstraint)
data Inh_RowConstraint = Inh_RowConstraint {cat_Inh_RowConstraint :: Catalog,lib_Inh_RowConstraint :: LocalIdentifierBindings}
data Syn_RowConstraint = Syn_RowConstraint {annotatedTree_Syn_RowConstraint :: RowConstraint,originalTree_Syn_RowConstraint :: RowConstraint}
wrap_RowConstraint :: T_RowConstraint ->
Inh_RowConstraint ->
Syn_RowConstraint
wrap_RowConstraint sem (Inh_RowConstraint _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_RowConstraint _lhsOannotatedTree _lhsOoriginalTree ))
sem_RowConstraint_NotNullConstraint :: Annotation ->
String ->
T_RowConstraint
sem_RowConstraint_NotNullConstraint ann_ name_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: RowConstraint
_lhsOoriginalTree :: RowConstraint
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
NotNullConstraint ann_ name_
{-# LINE 7526 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
NotNullConstraint ann_ name_
{-# LINE 7531 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 7536 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 7541 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
sem_RowConstraint_NullConstraint :: Annotation ->
String ->
T_RowConstraint
sem_RowConstraint_NullConstraint ann_ name_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: RowConstraint
_lhsOoriginalTree :: RowConstraint
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
NullConstraint ann_ name_
{-# LINE 7555 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
NullConstraint ann_ name_
{-# LINE 7560 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 7565 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 7570 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
sem_RowConstraint_RowCheckConstraint :: Annotation ->
String ->
T_Expression ->
T_RowConstraint
sem_RowConstraint_RowCheckConstraint ann_ name_ expression_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: RowConstraint
_lhsOoriginalTree :: RowConstraint
_expressionOcat :: Catalog
_expressionOlib :: LocalIdentifierBindings
_expressionIannotatedTree :: Expression
_expressionIliftedColumnName :: String
_expressionIoriginalTree :: Expression
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
RowCheckConstraint ann_ name_ _expressionIannotatedTree
{-# LINE 7590 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
RowCheckConstraint ann_ name_ _expressionIoriginalTree
{-# LINE 7595 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 7600 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 7605 "AstInternal.hs" #-}
-- copy rule (down)
_expressionOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 7610 "AstInternal.hs" #-}
-- copy rule (down)
_expressionOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 7615 "AstInternal.hs" #-}
( _expressionIannotatedTree,_expressionIliftedColumnName,_expressionIoriginalTree) =
(expression_ _expressionOcat _expressionOlib )
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
sem_RowConstraint_RowPrimaryKeyConstraint :: Annotation ->
String ->
T_RowConstraint
sem_RowConstraint_RowPrimaryKeyConstraint ann_ name_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: RowConstraint
_lhsOoriginalTree :: RowConstraint
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
RowPrimaryKeyConstraint ann_ name_
{-# LINE 7631 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
RowPrimaryKeyConstraint ann_ name_
{-# LINE 7636 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 7641 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 7646 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
sem_RowConstraint_RowReferenceConstraint :: Annotation ->
String ->
String ->
(Maybe String) ->
T_Cascade ->
T_Cascade ->
T_RowConstraint
sem_RowConstraint_RowReferenceConstraint ann_ name_ table_ att_ onUpdate_ onDelete_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: RowConstraint
_lhsOoriginalTree :: RowConstraint
_onUpdateOcat :: Catalog
_onUpdateOlib :: LocalIdentifierBindings
_onDeleteOcat :: Catalog
_onDeleteOlib :: LocalIdentifierBindings
_onUpdateIannotatedTree :: Cascade
_onUpdateIoriginalTree :: Cascade
_onDeleteIannotatedTree :: Cascade
_onDeleteIoriginalTree :: Cascade
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
RowReferenceConstraint ann_ name_ table_ att_ _onUpdateIannotatedTree _onDeleteIannotatedTree
{-# LINE 7672 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
RowReferenceConstraint ann_ name_ table_ att_ _onUpdateIoriginalTree _onDeleteIoriginalTree
{-# LINE 7677 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 7682 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 7687 "AstInternal.hs" #-}
-- copy rule (down)
_onUpdateOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 7692 "AstInternal.hs" #-}
-- copy rule (down)
_onUpdateOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 7697 "AstInternal.hs" #-}
-- copy rule (down)
_onDeleteOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 7702 "AstInternal.hs" #-}
-- copy rule (down)
_onDeleteOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 7707 "AstInternal.hs" #-}
( _onUpdateIannotatedTree,_onUpdateIoriginalTree) =
(onUpdate_ _onUpdateOcat _onUpdateOlib )
( _onDeleteIannotatedTree,_onDeleteIoriginalTree) =
(onDelete_ _onDeleteOcat _onDeleteOlib )
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
sem_RowConstraint_RowUniqueConstraint :: Annotation ->
String ->
T_RowConstraint
sem_RowConstraint_RowUniqueConstraint ann_ name_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: RowConstraint
_lhsOoriginalTree :: RowConstraint
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
RowUniqueConstraint ann_ name_
{-# LINE 7725 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
RowUniqueConstraint ann_ name_
{-# LINE 7730 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 7735 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 7740 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
-- RowConstraintList -------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
originalTree : SELF
alternatives:
alternative Cons:
child hd : RowConstraint
child tl : RowConstraintList
visit 0:
local annotatedTree : _
local originalTree : _
alternative Nil:
visit 0:
local annotatedTree : _
local originalTree : _
-}
type RowConstraintList = [(RowConstraint)]
-- cata
sem_RowConstraintList :: RowConstraintList ->
T_RowConstraintList
sem_RowConstraintList list =
(Prelude.foldr sem_RowConstraintList_Cons sem_RowConstraintList_Nil (Prelude.map sem_RowConstraint list) )
-- semantic domain
type T_RowConstraintList = Catalog ->
LocalIdentifierBindings ->
( RowConstraintList,RowConstraintList)
data Inh_RowConstraintList = Inh_RowConstraintList {cat_Inh_RowConstraintList :: Catalog,lib_Inh_RowConstraintList :: LocalIdentifierBindings}
data Syn_RowConstraintList = Syn_RowConstraintList {annotatedTree_Syn_RowConstraintList :: RowConstraintList,originalTree_Syn_RowConstraintList :: RowConstraintList}
wrap_RowConstraintList :: T_RowConstraintList ->
Inh_RowConstraintList ->
Syn_RowConstraintList
wrap_RowConstraintList sem (Inh_RowConstraintList _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_RowConstraintList _lhsOannotatedTree _lhsOoriginalTree ))
sem_RowConstraintList_Cons :: T_RowConstraint ->
T_RowConstraintList ->
T_RowConstraintList
sem_RowConstraintList_Cons hd_ tl_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: RowConstraintList
_lhsOoriginalTree :: RowConstraintList
_hdOcat :: Catalog
_hdOlib :: LocalIdentifierBindings
_tlOcat :: Catalog
_tlOlib :: LocalIdentifierBindings
_hdIannotatedTree :: RowConstraint
_hdIoriginalTree :: RowConstraint
_tlIannotatedTree :: RowConstraintList
_tlIoriginalTree :: RowConstraintList
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
(:) _hdIannotatedTree _tlIannotatedTree
{-# LINE 7802 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
(:) _hdIoriginalTree _tlIoriginalTree
{-# LINE 7807 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 7812 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 7817 "AstInternal.hs" #-}
-- copy rule (down)
_hdOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 7822 "AstInternal.hs" #-}
-- copy rule (down)
_hdOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 7827 "AstInternal.hs" #-}
-- copy rule (down)
_tlOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 7832 "AstInternal.hs" #-}
-- copy rule (down)
_tlOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 7837 "AstInternal.hs" #-}
( _hdIannotatedTree,_hdIoriginalTree) =
(hd_ _hdOcat _hdOlib )
( _tlIannotatedTree,_tlIoriginalTree) =
(tl_ _tlOcat _tlOlib )
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
sem_RowConstraintList_Nil :: T_RowConstraintList
sem_RowConstraintList_Nil =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: RowConstraintList
_lhsOoriginalTree :: RowConstraintList
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
[]
{-# LINE 7853 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
[]
{-# LINE 7858 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 7863 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 7868 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
-- SelectExpression --------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
libUpdates : [LocalIdentifierBindingsUpdate]
originalTree : SELF
alternatives:
alternative CombineSelect:
child ann : {Annotation}
child ctype : CombineType
child sel1 : SelectExpression
child sel2 : SelectExpression
visit 0:
local tpe : _
local backTree : _
local annotatedTree : _
local originalTree : _
alternative Select:
child ann : {Annotation}
child selDistinct : Distinct
child selSelectList : SelectList
child selTref : TableRefList
child selWhere : MaybeBoolExpression
child selGroupBy : ExpressionList
child selHaving : MaybeBoolExpression
child selOrderBy : ExpressionDirectionPairList
child selLimit : MaybeExpression
child selOffset : MaybeExpression
visit 0:
local newLib : _
local tpe : _
local backTree : _
local annotatedTree : _
local originalTree : _
alternative Values:
child ann : {Annotation}
child vll : ExpressionListList
visit 0:
local tpe : _
local backTree : _
local annotatedTree : _
local originalTree : _
-}
data SelectExpression = CombineSelect (Annotation) (CombineType) (SelectExpression) (SelectExpression)
| Select (Annotation) (Distinct) (SelectList) (TableRefList) (MaybeBoolExpression) (ExpressionList) (MaybeBoolExpression) (ExpressionDirectionPairList) (MaybeExpression) (MaybeExpression)
| Values (Annotation) (ExpressionListList)
deriving ( Data,Eq,Show,Typeable)
-- cata
sem_SelectExpression :: SelectExpression ->
T_SelectExpression
sem_SelectExpression (CombineSelect _ann _ctype _sel1 _sel2 ) =
(sem_SelectExpression_CombineSelect _ann (sem_CombineType _ctype ) (sem_SelectExpression _sel1 ) (sem_SelectExpression _sel2 ) )
sem_SelectExpression (Select _ann _selDistinct _selSelectList _selTref _selWhere _selGroupBy _selHaving _selOrderBy _selLimit _selOffset ) =
(sem_SelectExpression_Select _ann (sem_Distinct _selDistinct ) (sem_SelectList _selSelectList ) (sem_TableRefList _selTref ) (sem_MaybeBoolExpression _selWhere ) (sem_ExpressionList _selGroupBy ) (sem_MaybeBoolExpression _selHaving ) (sem_ExpressionDirectionPairList _selOrderBy ) (sem_MaybeExpression _selLimit ) (sem_MaybeExpression _selOffset ) )
sem_SelectExpression (Values _ann _vll ) =
(sem_SelectExpression_Values _ann (sem_ExpressionListList _vll ) )
-- semantic domain
type T_SelectExpression = Catalog ->
LocalIdentifierBindings ->
( SelectExpression,([LocalIdentifierBindingsUpdate]),SelectExpression)
data Inh_SelectExpression = Inh_SelectExpression {cat_Inh_SelectExpression :: Catalog,lib_Inh_SelectExpression :: LocalIdentifierBindings}
data Syn_SelectExpression = Syn_SelectExpression {annotatedTree_Syn_SelectExpression :: SelectExpression,libUpdates_Syn_SelectExpression :: [LocalIdentifierBindingsUpdate],originalTree_Syn_SelectExpression :: SelectExpression}
wrap_SelectExpression :: T_SelectExpression ->
Inh_SelectExpression ->
Syn_SelectExpression
wrap_SelectExpression sem (Inh_SelectExpression _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOlibUpdates,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_SelectExpression _lhsOannotatedTree _lhsOlibUpdates _lhsOoriginalTree ))
sem_SelectExpression_CombineSelect :: Annotation ->
T_CombineType ->
T_SelectExpression ->
T_SelectExpression ->
T_SelectExpression
sem_SelectExpression_CombineSelect ann_ ctype_ sel1_ sel2_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: SelectExpression
_lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_lhsOoriginalTree :: SelectExpression
_ctypeOcat :: Catalog
_ctypeOlib :: LocalIdentifierBindings
_sel1Ocat :: Catalog
_sel1Olib :: LocalIdentifierBindings
_sel2Ocat :: Catalog
_sel2Olib :: LocalIdentifierBindings
_ctypeIannotatedTree :: CombineType
_ctypeIoriginalTree :: CombineType
_sel1IannotatedTree :: SelectExpression
_sel1IlibUpdates :: ([LocalIdentifierBindingsUpdate])
_sel1IoriginalTree :: SelectExpression
_sel2IannotatedTree :: SelectExpression
_sel2IlibUpdates :: ([LocalIdentifierBindingsUpdate])
_sel2IoriginalTree :: SelectExpression
-- "./TypeChecking/SelectStatement.ag"(line 23, column 9)
_lhsOannotatedTree =
{-# LINE 23 "./TypeChecking/SelectStatement.ag" #-}
annTypesAndErrors _backTree
(tpeToT _tpe )
(getErrors _tpe )
Nothing
{-# LINE 7975 "AstInternal.hs" #-}
-- "./TypeChecking/SelectStatement.ag"(line 129, column 9)
_tpe =
{-# LINE 129 "./TypeChecking/SelectStatement.ag" #-}
let sel1t = getTypeAnnotation _sel1IannotatedTree
sel2t = getTypeAnnotation _sel2IannotatedTree
in dependsOnRTpe [sel1t, sel2t] $
typeCheckCombineSelect _lhsIcat sel1t sel2t
{-# LINE 7983 "AstInternal.hs" #-}
-- "./TypeChecking/SelectStatement.ag"(line 134, column 9)
_backTree =
{-# LINE 134 "./TypeChecking/SelectStatement.ag" #-}
CombineSelect ann_ _ctypeIannotatedTree
_sel1IannotatedTree
_sel2IannotatedTree
{-# LINE 7990 "AstInternal.hs" #-}
-- "./TypeChecking/SelectLists.ag"(line 87, column 11)
_lhsOlibUpdates =
{-# LINE 87 "./TypeChecking/SelectLists.ag" #-}
[]
{-# LINE 7995 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
CombineSelect ann_ _ctypeIannotatedTree _sel1IannotatedTree _sel2IannotatedTree
{-# LINE 8000 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
CombineSelect ann_ _ctypeIoriginalTree _sel1IoriginalTree _sel2IoriginalTree
{-# LINE 8005 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 8010 "AstInternal.hs" #-}
-- copy rule (down)
_ctypeOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 8015 "AstInternal.hs" #-}
-- copy rule (down)
_ctypeOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 8020 "AstInternal.hs" #-}
-- copy rule (down)
_sel1Ocat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 8025 "AstInternal.hs" #-}
-- copy rule (down)
_sel1Olib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 8030 "AstInternal.hs" #-}
-- copy rule (down)
_sel2Ocat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 8035 "AstInternal.hs" #-}
-- copy rule (down)
_sel2Olib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 8040 "AstInternal.hs" #-}
( _ctypeIannotatedTree,_ctypeIoriginalTree) =
(ctype_ _ctypeOcat _ctypeOlib )
( _sel1IannotatedTree,_sel1IlibUpdates,_sel1IoriginalTree) =
(sel1_ _sel1Ocat _sel1Olib )
( _sel2IannotatedTree,_sel2IlibUpdates,_sel2IoriginalTree) =
(sel2_ _sel2Ocat _sel2Olib )
in ( _lhsOannotatedTree,_lhsOlibUpdates,_lhsOoriginalTree)))
sem_SelectExpression_Select :: Annotation ->
T_Distinct ->
T_SelectList ->
T_TableRefList ->
T_MaybeBoolExpression ->
T_ExpressionList ->
T_MaybeBoolExpression ->
T_ExpressionDirectionPairList ->
T_MaybeExpression ->
T_MaybeExpression ->
T_SelectExpression
sem_SelectExpression_Select ann_ selDistinct_ selSelectList_ selTref_ selWhere_ selGroupBy_ selHaving_ selOrderBy_ selLimit_ selOffset_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: SelectExpression
_selSelectListOlib :: LocalIdentifierBindings
_selWhereOlib :: LocalIdentifierBindings
_selGroupByOlib :: LocalIdentifierBindings
_selOrderByOlib :: LocalIdentifierBindings
_lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_lhsOoriginalTree :: SelectExpression
_selDistinctOcat :: Catalog
_selDistinctOlib :: LocalIdentifierBindings
_selSelectListOcat :: Catalog
_selTrefOcat :: Catalog
_selTrefOlib :: LocalIdentifierBindings
_selWhereOcat :: Catalog
_selGroupByOcat :: Catalog
_selHavingOcat :: Catalog
_selHavingOlib :: LocalIdentifierBindings
_selOrderByOcat :: Catalog
_selLimitOcat :: Catalog
_selLimitOlib :: LocalIdentifierBindings
_selOffsetOcat :: Catalog
_selOffsetOlib :: LocalIdentifierBindings
_selDistinctIannotatedTree :: Distinct
_selDistinctIoriginalTree :: Distinct
_selSelectListIannotatedTree :: SelectList
_selSelectListIlibUpdates :: ([LocalIdentifierBindingsUpdate])
_selSelectListIlistType :: ([(String,Type)])
_selSelectListIoriginalTree :: SelectList
_selTrefIannotatedTree :: TableRefList
_selTrefIlibUpdates :: ([LocalIdentifierBindingsUpdate])
_selTrefIoriginalTree :: TableRefList
_selWhereIannotatedTree :: MaybeBoolExpression
_selWhereIoriginalTree :: MaybeBoolExpression
_selGroupByIannotatedTree :: ExpressionList
_selGroupByIoriginalTree :: ExpressionList
_selGroupByItypeList :: ([Type])
_selHavingIannotatedTree :: MaybeBoolExpression
_selHavingIoriginalTree :: MaybeBoolExpression
_selOrderByIannotatedTree :: ExpressionDirectionPairList
_selOrderByIoriginalTree :: ExpressionDirectionPairList
_selLimitIannotatedTree :: MaybeExpression
_selLimitIoriginalTree :: MaybeExpression
_selOffsetIannotatedTree :: MaybeExpression
_selOffsetIoriginalTree :: MaybeExpression
-- "./TypeChecking/SelectStatement.ag"(line 23, column 9)
_lhsOannotatedTree =
{-# LINE 23 "./TypeChecking/SelectStatement.ag" #-}
annTypesAndErrors _backTree
(tpeToT _tpe )
(getErrors _tpe )
Nothing
{-# LINE 8112 "AstInternal.hs" #-}
-- "./TypeChecking/SelectStatement.ag"(line 94, column 10)
_newLib =
{-# LINE 94 "./TypeChecking/SelectStatement.ag" #-}
case updateBindings _lhsIlib _lhsIcat _selTrefIlibUpdates of
Left x -> error $ show x
Right e -> e
{-# LINE 8119 "AstInternal.hs" #-}
-- "./TypeChecking/SelectStatement.ag"(line 97, column 10)
_selSelectListOlib =
{-# LINE 97 "./TypeChecking/SelectStatement.ag" #-}
_newLib
{-# LINE 8124 "AstInternal.hs" #-}
-- "./TypeChecking/SelectStatement.ag"(line 98, column 10)
_selWhereOlib =
{-# LINE 98 "./TypeChecking/SelectStatement.ag" #-}
_newLib
{-# LINE 8129 "AstInternal.hs" #-}
-- "./TypeChecking/SelectStatement.ag"(line 99, column 10)
_selGroupByOlib =
{-# LINE 99 "./TypeChecking/SelectStatement.ag" #-}
_newLib
{-# LINE 8134 "AstInternal.hs" #-}
-- "./TypeChecking/SelectStatement.ag"(line 100, column 10)
_selOrderByOlib =
{-# LINE 100 "./TypeChecking/SelectStatement.ag" #-}
_newLib
{-# LINE 8139 "AstInternal.hs" #-}
-- "./TypeChecking/SelectStatement.ag"(line 111, column 9)
_tpe =
{-# LINE 111 "./TypeChecking/SelectStatement.ag" #-}
do
Right $ case _selSelectListIlistType of
[(_,Pseudo Void)] -> Pseudo Void
_ -> SetOfType $ CompositeType _selSelectListIlistType
{-# LINE 8147 "AstInternal.hs" #-}
-- "./TypeChecking/SelectStatement.ag"(line 118, column 9)
_backTree =
{-# LINE 118 "./TypeChecking/SelectStatement.ag" #-}
Select ann_
_selDistinctIannotatedTree
_selSelectListIannotatedTree
_selTrefIannotatedTree
_selWhereIannotatedTree
_selGroupByIannotatedTree
_selHavingIannotatedTree
_selOrderByIannotatedTree
_selLimitIannotatedTree
_selOffsetIannotatedTree
{-# LINE 8161 "AstInternal.hs" #-}
-- "./TypeChecking/SelectLists.ag"(line 85, column 9)
_lhsOlibUpdates =
{-# LINE 85 "./TypeChecking/SelectLists.ag" #-}
_selSelectListIlibUpdates
{-# LINE 8166 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
Select ann_ _selDistinctIannotatedTree _selSelectListIannotatedTree _selTrefIannotatedTree _selWhereIannotatedTree _selGroupByIannotatedTree _selHavingIannotatedTree _selOrderByIannotatedTree _selLimitIannotatedTree _selOffsetIannotatedTree
{-# LINE 8171 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
Select ann_ _selDistinctIoriginalTree _selSelectListIoriginalTree _selTrefIoriginalTree _selWhereIoriginalTree _selGroupByIoriginalTree _selHavingIoriginalTree _selOrderByIoriginalTree _selLimitIoriginalTree _selOffsetIoriginalTree
{-# LINE 8176 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 8181 "AstInternal.hs" #-}
-- copy rule (down)
_selDistinctOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 8186 "AstInternal.hs" #-}
-- copy rule (down)
_selDistinctOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 8191 "AstInternal.hs" #-}
-- copy rule (down)
_selSelectListOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 8196 "AstInternal.hs" #-}
-- copy rule (down)
_selTrefOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 8201 "AstInternal.hs" #-}
-- copy rule (down)
_selTrefOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 8206 "AstInternal.hs" #-}
-- copy rule (down)
_selWhereOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 8211 "AstInternal.hs" #-}
-- copy rule (down)
_selGroupByOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 8216 "AstInternal.hs" #-}
-- copy rule (down)
_selHavingOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 8221 "AstInternal.hs" #-}
-- copy rule (down)
_selHavingOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 8226 "AstInternal.hs" #-}
-- copy rule (down)
_selOrderByOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 8231 "AstInternal.hs" #-}
-- copy rule (down)
_selLimitOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 8236 "AstInternal.hs" #-}
-- copy rule (down)
_selLimitOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 8241 "AstInternal.hs" #-}
-- copy rule (down)
_selOffsetOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 8246 "AstInternal.hs" #-}
-- copy rule (down)
_selOffsetOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 8251 "AstInternal.hs" #-}
( _selDistinctIannotatedTree,_selDistinctIoriginalTree) =
(selDistinct_ _selDistinctOcat _selDistinctOlib )
( _selSelectListIannotatedTree,_selSelectListIlibUpdates,_selSelectListIlistType,_selSelectListIoriginalTree) =
(selSelectList_ _selSelectListOcat _selSelectListOlib )
( _selTrefIannotatedTree,_selTrefIlibUpdates,_selTrefIoriginalTree) =
(selTref_ _selTrefOcat _selTrefOlib )
( _selWhereIannotatedTree,_selWhereIoriginalTree) =
(selWhere_ _selWhereOcat _selWhereOlib )
( _selGroupByIannotatedTree,_selGroupByIoriginalTree,_selGroupByItypeList) =
(selGroupBy_ _selGroupByOcat _selGroupByOlib )
( _selHavingIannotatedTree,_selHavingIoriginalTree) =
(selHaving_ _selHavingOcat _selHavingOlib )
( _selOrderByIannotatedTree,_selOrderByIoriginalTree) =
(selOrderBy_ _selOrderByOcat _selOrderByOlib )
( _selLimitIannotatedTree,_selLimitIoriginalTree) =
(selLimit_ _selLimitOcat _selLimitOlib )
( _selOffsetIannotatedTree,_selOffsetIoriginalTree) =
(selOffset_ _selOffsetOcat _selOffsetOlib )
in ( _lhsOannotatedTree,_lhsOlibUpdates,_lhsOoriginalTree)))
sem_SelectExpression_Values :: Annotation ->
T_ExpressionListList ->
T_SelectExpression
sem_SelectExpression_Values ann_ vll_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: SelectExpression
_lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_lhsOoriginalTree :: SelectExpression
_vllOcat :: Catalog
_vllOlib :: LocalIdentifierBindings
_vllIannotatedTree :: ExpressionListList
_vllIoriginalTree :: ExpressionListList
_vllItypeListList :: ([[Type]])
-- "./TypeChecking/SelectStatement.ag"(line 23, column 9)
_lhsOannotatedTree =
{-# LINE 23 "./TypeChecking/SelectStatement.ag" #-}
annTypesAndErrors _backTree
(tpeToT _tpe )
(getErrors _tpe )
Nothing
{-# LINE 8292 "AstInternal.hs" #-}
-- "./TypeChecking/SelectStatement.ag"(line 106, column 9)
_tpe =
{-# LINE 106 "./TypeChecking/SelectStatement.ag" #-}
typeCheckValuesExpr
_lhsIcat
_vllItypeListList
{-# LINE 8299 "AstInternal.hs" #-}
-- "./TypeChecking/SelectStatement.ag"(line 109, column 9)
_backTree =
{-# LINE 109 "./TypeChecking/SelectStatement.ag" #-}
Values ann_ _vllIannotatedTree
{-# LINE 8304 "AstInternal.hs" #-}
-- "./TypeChecking/SelectLists.ag"(line 87, column 11)
_lhsOlibUpdates =
{-# LINE 87 "./TypeChecking/SelectLists.ag" #-}
[]
{-# LINE 8309 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
Values ann_ _vllIannotatedTree
{-# LINE 8314 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
Values ann_ _vllIoriginalTree
{-# LINE 8319 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 8324 "AstInternal.hs" #-}
-- copy rule (down)
_vllOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 8329 "AstInternal.hs" #-}
-- copy rule (down)
_vllOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 8334 "AstInternal.hs" #-}
( _vllIannotatedTree,_vllIoriginalTree,_vllItypeListList) =
(vll_ _vllOcat _vllOlib )
in ( _lhsOannotatedTree,_lhsOlibUpdates,_lhsOoriginalTree)))
-- SelectItem --------------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
columnName : String
itemType : Type
originalTree : SELF
alternatives:
alternative SelExp:
child ann : {Annotation}
child ex : Expression
visit 0:
local annotatedTree : _
local originalTree : _
alternative SelectItem:
child ann : {Annotation}
child ex : Expression
child name : {String}
visit 0:
local annotatedTree : _
local originalTree : _
-}
data SelectItem = SelExp (Annotation) (Expression)
| SelectItem (Annotation) (Expression) (String)
deriving ( Data,Eq,Show,Typeable)
-- cata
sem_SelectItem :: SelectItem ->
T_SelectItem
sem_SelectItem (SelExp _ann _ex ) =
(sem_SelectItem_SelExp _ann (sem_Expression _ex ) )
sem_SelectItem (SelectItem _ann _ex _name ) =
(sem_SelectItem_SelectItem _ann (sem_Expression _ex ) _name )
-- semantic domain
type T_SelectItem = Catalog ->
LocalIdentifierBindings ->
( SelectItem,String,Type,SelectItem)
data Inh_SelectItem = Inh_SelectItem {cat_Inh_SelectItem :: Catalog,lib_Inh_SelectItem :: LocalIdentifierBindings}
data Syn_SelectItem = Syn_SelectItem {annotatedTree_Syn_SelectItem :: SelectItem,columnName_Syn_SelectItem :: String,itemType_Syn_SelectItem :: Type,originalTree_Syn_SelectItem :: SelectItem}
wrap_SelectItem :: T_SelectItem ->
Inh_SelectItem ->
Syn_SelectItem
wrap_SelectItem sem (Inh_SelectItem _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOcolumnName,_lhsOitemType,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_SelectItem _lhsOannotatedTree _lhsOcolumnName _lhsOitemType _lhsOoriginalTree ))
sem_SelectItem_SelExp :: Annotation ->
T_Expression ->
T_SelectItem
sem_SelectItem_SelExp ann_ ex_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOitemType :: Type
_lhsOcolumnName :: String
_lhsOannotatedTree :: SelectItem
_lhsOoriginalTree :: SelectItem
_exOcat :: Catalog
_exOlib :: LocalIdentifierBindings
_exIannotatedTree :: Expression
_exIliftedColumnName :: String
_exIoriginalTree :: Expression
-- "./TypeChecking/SelectLists.ag"(line 13, column 9)
_annotatedTree =
{-# LINE 13 "./TypeChecking/SelectLists.ag" #-}
SelExp ann_ $ fixStar _exIannotatedTree
{-# LINE 8406 "AstInternal.hs" #-}
-- "./TypeChecking/SelectLists.ag"(line 35, column 9)
_lhsOitemType =
{-# LINE 35 "./TypeChecking/SelectLists.ag" #-}
getTypeAnnotation _exIannotatedTree
{-# LINE 8411 "AstInternal.hs" #-}
-- "./TypeChecking/SelectLists.ag"(line 181, column 14)
_lhsOcolumnName =
{-# LINE 181 "./TypeChecking/SelectLists.ag" #-}
case _exIliftedColumnName of
"" -> "?column?"
s -> s
{-# LINE 8418 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
SelExp ann_ _exIoriginalTree
{-# LINE 8423 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 8428 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 8433 "AstInternal.hs" #-}
-- copy rule (down)
_exOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 8438 "AstInternal.hs" #-}
-- copy rule (down)
_exOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 8443 "AstInternal.hs" #-}
( _exIannotatedTree,_exIliftedColumnName,_exIoriginalTree) =
(ex_ _exOcat _exOlib )
in ( _lhsOannotatedTree,_lhsOcolumnName,_lhsOitemType,_lhsOoriginalTree)))
sem_SelectItem_SelectItem :: Annotation ->
T_Expression ->
String ->
T_SelectItem
sem_SelectItem_SelectItem ann_ ex_ name_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOitemType :: Type
_lhsOcolumnName :: String
_lhsOannotatedTree :: SelectItem
_lhsOoriginalTree :: SelectItem
_exOcat :: Catalog
_exOlib :: LocalIdentifierBindings
_exIannotatedTree :: Expression
_exIliftedColumnName :: String
_exIoriginalTree :: Expression
-- "./TypeChecking/SelectLists.ag"(line 15, column 9)
_annotatedTree =
{-# LINE 15 "./TypeChecking/SelectLists.ag" #-}
SelectItem ann_ (fixStar _exIannotatedTree) name_
{-# LINE 8467 "AstInternal.hs" #-}
-- "./TypeChecking/SelectLists.ag"(line 35, column 9)
_lhsOitemType =
{-# LINE 35 "./TypeChecking/SelectLists.ag" #-}
getTypeAnnotation _exIannotatedTree
{-# LINE 8472 "AstInternal.hs" #-}
-- "./TypeChecking/SelectLists.ag"(line 184, column 18)
_lhsOcolumnName =
{-# LINE 184 "./TypeChecking/SelectLists.ag" #-}
name_
{-# LINE 8477 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
SelectItem ann_ _exIoriginalTree name_
{-# LINE 8482 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 8487 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 8492 "AstInternal.hs" #-}
-- copy rule (down)
_exOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 8497 "AstInternal.hs" #-}
-- copy rule (down)
_exOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 8502 "AstInternal.hs" #-}
( _exIannotatedTree,_exIliftedColumnName,_exIoriginalTree) =
(ex_ _exOcat _exOlib )
in ( _lhsOannotatedTree,_lhsOcolumnName,_lhsOitemType,_lhsOoriginalTree)))
-- SelectItemList ----------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
listType : [(String,Type)]
originalTree : SELF
alternatives:
alternative Cons:
child hd : SelectItem
child tl : SelectItemList
visit 0:
local annotatedTree : _
local originalTree : _
alternative Nil:
visit 0:
local annotatedTree : _
local originalTree : _
-}
type SelectItemList = [(SelectItem)]
-- cata
sem_SelectItemList :: SelectItemList ->
T_SelectItemList
sem_SelectItemList list =
(Prelude.foldr sem_SelectItemList_Cons sem_SelectItemList_Nil (Prelude.map sem_SelectItem list) )
-- semantic domain
type T_SelectItemList = Catalog ->
LocalIdentifierBindings ->
( SelectItemList,([(String,Type)]),SelectItemList)
data Inh_SelectItemList = Inh_SelectItemList {cat_Inh_SelectItemList :: Catalog,lib_Inh_SelectItemList :: LocalIdentifierBindings}
data Syn_SelectItemList = Syn_SelectItemList {annotatedTree_Syn_SelectItemList :: SelectItemList,listType_Syn_SelectItemList :: [(String,Type)],originalTree_Syn_SelectItemList :: SelectItemList}
wrap_SelectItemList :: T_SelectItemList ->
Inh_SelectItemList ->
Syn_SelectItemList
wrap_SelectItemList sem (Inh_SelectItemList _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOlistType,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_SelectItemList _lhsOannotatedTree _lhsOlistType _lhsOoriginalTree ))
sem_SelectItemList_Cons :: T_SelectItem ->
T_SelectItemList ->
T_SelectItemList
sem_SelectItemList_Cons hd_ tl_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOlistType :: ([(String,Type)])
_lhsOannotatedTree :: SelectItemList
_lhsOoriginalTree :: SelectItemList
_hdOcat :: Catalog
_hdOlib :: LocalIdentifierBindings
_tlOcat :: Catalog
_tlOlib :: LocalIdentifierBindings
_hdIannotatedTree :: SelectItem
_hdIcolumnName :: String
_hdIitemType :: Type
_hdIoriginalTree :: SelectItem
_tlIannotatedTree :: SelectItemList
_tlIlistType :: ([(String,Type)])
_tlIoriginalTree :: SelectItemList
-- "./TypeChecking/SelectLists.ag"(line 29, column 12)
_lhsOlistType =
{-# LINE 29 "./TypeChecking/SelectLists.ag" #-}
expandStar _lhsIlib _hdIcolumnName _hdIitemType _tlIlistType
{-# LINE 8571 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
(:) _hdIannotatedTree _tlIannotatedTree
{-# LINE 8576 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
(:) _hdIoriginalTree _tlIoriginalTree
{-# LINE 8581 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 8586 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 8591 "AstInternal.hs" #-}
-- copy rule (down)
_hdOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 8596 "AstInternal.hs" #-}
-- copy rule (down)
_hdOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 8601 "AstInternal.hs" #-}
-- copy rule (down)
_tlOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 8606 "AstInternal.hs" #-}
-- copy rule (down)
_tlOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 8611 "AstInternal.hs" #-}
( _hdIannotatedTree,_hdIcolumnName,_hdIitemType,_hdIoriginalTree) =
(hd_ _hdOcat _hdOlib )
( _tlIannotatedTree,_tlIlistType,_tlIoriginalTree) =
(tl_ _tlOcat _tlOlib )
in ( _lhsOannotatedTree,_lhsOlistType,_lhsOoriginalTree)))
sem_SelectItemList_Nil :: T_SelectItemList
sem_SelectItemList_Nil =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOlistType :: ([(String,Type)])
_lhsOannotatedTree :: SelectItemList
_lhsOoriginalTree :: SelectItemList
-- "./TypeChecking/SelectLists.ag"(line 30, column 11)
_lhsOlistType =
{-# LINE 30 "./TypeChecking/SelectLists.ag" #-}
[]
{-# LINE 8628 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
[]
{-# LINE 8633 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
[]
{-# LINE 8638 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 8643 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 8648 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOlistType,_lhsOoriginalTree)))
-- SelectList --------------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
libUpdates : [LocalIdentifierBindingsUpdate]
listType : [(String,Type)]
originalTree : SELF
alternatives:
alternative SelectList:
child ann : {Annotation}
child items : SelectItemList
child into : StringList
visit 0:
local errs : _
local stuff : _
local annotatedTree : _
local originalTree : _
-}
data SelectList = SelectList (Annotation) (SelectItemList) (StringList)
deriving ( Data,Eq,Show,Typeable)
-- cata
sem_SelectList :: SelectList ->
T_SelectList
sem_SelectList (SelectList _ann _items _into ) =
(sem_SelectList_SelectList _ann (sem_SelectItemList _items ) (sem_StringList _into ) )
-- semantic domain
type T_SelectList = Catalog ->
LocalIdentifierBindings ->
( SelectList,([LocalIdentifierBindingsUpdate]),([(String,Type)]),SelectList)
data Inh_SelectList = Inh_SelectList {cat_Inh_SelectList :: Catalog,lib_Inh_SelectList :: LocalIdentifierBindings}
data Syn_SelectList = Syn_SelectList {annotatedTree_Syn_SelectList :: SelectList,libUpdates_Syn_SelectList :: [LocalIdentifierBindingsUpdate],listType_Syn_SelectList :: [(String,Type)],originalTree_Syn_SelectList :: SelectList}
wrap_SelectList :: T_SelectList ->
Inh_SelectList ->
Syn_SelectList
wrap_SelectList sem (Inh_SelectList _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOlibUpdates,_lhsOlistType,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_SelectList _lhsOannotatedTree _lhsOlibUpdates _lhsOlistType _lhsOoriginalTree ))
sem_SelectList_SelectList :: Annotation ->
T_SelectItemList ->
T_StringList ->
T_SelectList
sem_SelectList_SelectList ann_ items_ into_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOlistType :: ([(String,Type)])
_lhsOannotatedTree :: SelectList
_lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_lhsOoriginalTree :: SelectList
_itemsOcat :: Catalog
_itemsOlib :: LocalIdentifierBindings
_intoOcat :: Catalog
_intoOlib :: LocalIdentifierBindings
_itemsIannotatedTree :: SelectItemList
_itemsIlistType :: ([(String,Type)])
_itemsIoriginalTree :: SelectItemList
_intoIannotatedTree :: StringList
_intoIoriginalTree :: StringList
_intoIstrings :: ([String])
-- "./TypeChecking/SelectLists.ag"(line 41, column 9)
_lhsOlistType =
{-# LINE 41 "./TypeChecking/SelectLists.ag" #-}
_itemsIlistType
{-# LINE 8717 "AstInternal.hs" #-}
-- "./TypeChecking/SelectLists.ag"(line 43, column 9)
_errs =
{-# LINE 43 "./TypeChecking/SelectLists.ag" #-}
case _stuff of
(er,_) -> er
{-# LINE 8723 "AstInternal.hs" #-}
-- "./TypeChecking/SelectLists.ag"(line 45, column 9)
_stuff =
{-# LINE 45 "./TypeChecking/SelectLists.ag" #-}
case () of
_ | null sl -> ([],Nothing)
| not (null targetTypeErrs) -> (targetTypeErrs,Nothing)
| (case targetTypes of
[PgRecord _] -> True
_ -> False) -> ([],Just (head sl, CompositeType _itemsIlistType))
| matchingComposite /= Left [] -> (fromLeft [] matchingComposite,Nothing)
| length sl /= length _itemsIlistType -> ([WrongNumberOfColumns],Nothing)
| not (null assignErrs) -> (assignErrs,Nothing)
| otherwise -> ([],Nothing)
where
targetTypeEithers = map (libLookupID _lhsIlib) sl
targetTypeErrs = concat $ lefts $ targetTypeEithers
targetTypes = rights $ targetTypeEithers
typePairs = zip (map snd _itemsIlistType) targetTypes
assignErrs = concat $ lefts $ map (uncurry $ checkAssignmentValid _lhsIcat) typePairs
sl = _intoIstrings
matchingComposite =
case targetTypes of
[t] | isCompositeType t -> checkAssignmentValid _lhsIcat (AnonymousRecordType (map snd _itemsIlistType)) t
_ -> Left []
{-# LINE 8748 "AstInternal.hs" #-}
-- "./TypeChecking/SelectLists.ag"(line 68, column 9)
_lhsOannotatedTree =
{-# LINE 68 "./TypeChecking/SelectLists.ag" #-}
SelectList (ann_ ++ map TypeErrorA _errs )
_itemsIannotatedTree
_intoIannotatedTree
{-# LINE 8755 "AstInternal.hs" #-}
-- "./TypeChecking/SelectLists.ag"(line 71, column 9)
_lhsOlibUpdates =
{-# LINE 71 "./TypeChecking/SelectLists.ag" #-}
case _stuff of
(_,Just r) -> [LibStackIDs [("", [r])]]
_ -> []
{-# LINE 8762 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
SelectList ann_ _itemsIannotatedTree _intoIannotatedTree
{-# LINE 8767 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
SelectList ann_ _itemsIoriginalTree _intoIoriginalTree
{-# LINE 8772 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 8777 "AstInternal.hs" #-}
-- copy rule (down)
_itemsOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 8782 "AstInternal.hs" #-}
-- copy rule (down)
_itemsOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 8787 "AstInternal.hs" #-}
-- copy rule (down)
_intoOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 8792 "AstInternal.hs" #-}
-- copy rule (down)
_intoOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 8797 "AstInternal.hs" #-}
( _itemsIannotatedTree,_itemsIlistType,_itemsIoriginalTree) =
(items_ _itemsOcat _itemsOlib )
( _intoIannotatedTree,_intoIoriginalTree,_intoIstrings) =
(into_ _intoOcat _intoOlib )
in ( _lhsOannotatedTree,_lhsOlibUpdates,_lhsOlistType,_lhsOoriginalTree)))
-- SetClause ---------------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
originalTree : SELF
pairs : [(String,Type)]
rowSetError : Maybe TypeError
alternatives:
alternative RowSetClause:
child ann : {Annotation}
child atts : StringList
child vals : ExpressionList
visit 0:
local rowSetError : _
local annotatedTree : _
local originalTree : _
alternative SetClause:
child ann : {Annotation}
child att : {String}
child val : Expression
visit 0:
local annotatedTree : _
local originalTree : _
-}
data SetClause = RowSetClause (Annotation) (StringList) (ExpressionList)
| SetClause (Annotation) (String) (Expression)
deriving ( Data,Eq,Show,Typeable)
-- cata
sem_SetClause :: SetClause ->
T_SetClause
sem_SetClause (RowSetClause _ann _atts _vals ) =
(sem_SetClause_RowSetClause _ann (sem_StringList _atts ) (sem_ExpressionList _vals ) )
sem_SetClause (SetClause _ann _att _val ) =
(sem_SetClause_SetClause _ann _att (sem_Expression _val ) )
-- semantic domain
type T_SetClause = Catalog ->
LocalIdentifierBindings ->
( SetClause,SetClause,([(String,Type)]),(Maybe TypeError))
data Inh_SetClause = Inh_SetClause {cat_Inh_SetClause :: Catalog,lib_Inh_SetClause :: LocalIdentifierBindings}
data Syn_SetClause = Syn_SetClause {annotatedTree_Syn_SetClause :: SetClause,originalTree_Syn_SetClause :: SetClause,pairs_Syn_SetClause :: [(String,Type)],rowSetError_Syn_SetClause :: Maybe TypeError}
wrap_SetClause :: T_SetClause ->
Inh_SetClause ->
Syn_SetClause
wrap_SetClause sem (Inh_SetClause _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOpairs,_lhsOrowSetError) =
(sem _lhsIcat _lhsIlib )
in (Syn_SetClause _lhsOannotatedTree _lhsOoriginalTree _lhsOpairs _lhsOrowSetError ))
sem_SetClause_RowSetClause :: Annotation ->
T_StringList ->
T_ExpressionList ->
T_SetClause
sem_SetClause_RowSetClause ann_ atts_ vals_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOpairs :: ([(String,Type)])
_lhsOannotatedTree :: SetClause
_lhsOoriginalTree :: SetClause
_lhsOrowSetError :: (Maybe TypeError)
_attsOcat :: Catalog
_attsOlib :: LocalIdentifierBindings
_valsOcat :: Catalog
_valsOlib :: LocalIdentifierBindings
_attsIannotatedTree :: StringList
_attsIoriginalTree :: StringList
_attsIstrings :: ([String])
_valsIannotatedTree :: ExpressionList
_valsIoriginalTree :: ExpressionList
_valsItypeList :: ([Type])
-- "./TypeChecking/Dml.ag"(line 155, column 9)
_rowSetError =
{-# LINE 155 "./TypeChecking/Dml.ag" #-}
let atts = _attsIstrings
types = getRowTypes _valsItypeList
in if length atts /= length types
then Just WrongNumberOfColumns
else Nothing
{-# LINE 8883 "AstInternal.hs" #-}
-- "./TypeChecking/Dml.ag"(line 161, column 9)
_lhsOpairs =
{-# LINE 161 "./TypeChecking/Dml.ag" #-}
zip _attsIstrings $ getRowTypes _valsItypeList
{-# LINE 8888 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
RowSetClause ann_ _attsIannotatedTree _valsIannotatedTree
{-# LINE 8893 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
RowSetClause ann_ _attsIoriginalTree _valsIoriginalTree
{-# LINE 8898 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 8903 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 8908 "AstInternal.hs" #-}
-- copy rule (from local)
_lhsOrowSetError =
{-# LINE 148 "./TypeChecking/Dml.ag" #-}
_rowSetError
{-# LINE 8913 "AstInternal.hs" #-}
-- copy rule (down)
_attsOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 8918 "AstInternal.hs" #-}
-- copy rule (down)
_attsOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 8923 "AstInternal.hs" #-}
-- copy rule (down)
_valsOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 8928 "AstInternal.hs" #-}
-- copy rule (down)
_valsOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 8933 "AstInternal.hs" #-}
( _attsIannotatedTree,_attsIoriginalTree,_attsIstrings) =
(atts_ _attsOcat _attsOlib )
( _valsIannotatedTree,_valsIoriginalTree,_valsItypeList) =
(vals_ _valsOcat _valsOlib )
in ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOpairs,_lhsOrowSetError)))
sem_SetClause_SetClause :: Annotation ->
String ->
T_Expression ->
T_SetClause
sem_SetClause_SetClause ann_ att_ val_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOpairs :: ([(String,Type)])
_lhsOrowSetError :: (Maybe TypeError)
_lhsOannotatedTree :: SetClause
_lhsOoriginalTree :: SetClause
_valOcat :: Catalog
_valOlib :: LocalIdentifierBindings
_valIannotatedTree :: Expression
_valIliftedColumnName :: String
_valIoriginalTree :: Expression
-- "./TypeChecking/Dml.ag"(line 152, column 9)
_lhsOpairs =
{-# LINE 152 "./TypeChecking/Dml.ag" #-}
[(att_, getTypeAnnotation _valIannotatedTree)]
{-# LINE 8959 "AstInternal.hs" #-}
-- "./TypeChecking/Dml.ag"(line 153, column 9)
_lhsOrowSetError =
{-# LINE 153 "./TypeChecking/Dml.ag" #-}
Nothing
{-# LINE 8964 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
SetClause ann_ att_ _valIannotatedTree
{-# LINE 8969 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
SetClause ann_ att_ _valIoriginalTree
{-# LINE 8974 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 8979 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 8984 "AstInternal.hs" #-}
-- copy rule (down)
_valOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 8989 "AstInternal.hs" #-}
-- copy rule (down)
_valOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 8994 "AstInternal.hs" #-}
( _valIannotatedTree,_valIliftedColumnName,_valIoriginalTree) =
(val_ _valOcat _valOlib )
in ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOpairs,_lhsOrowSetError)))
-- SetClauseList -----------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
originalTree : SELF
pairs : [(String,Type)]
rowSetErrors : [TypeError]
alternatives:
alternative Cons:
child hd : SetClause
child tl : SetClauseList
visit 0:
local annotatedTree : _
local originalTree : _
alternative Nil:
visit 0:
local annotatedTree : _
local originalTree : _
-}
type SetClauseList = [(SetClause)]
-- cata
sem_SetClauseList :: SetClauseList ->
T_SetClauseList
sem_SetClauseList list =
(Prelude.foldr sem_SetClauseList_Cons sem_SetClauseList_Nil (Prelude.map sem_SetClause list) )
-- semantic domain
type T_SetClauseList = Catalog ->
LocalIdentifierBindings ->
( SetClauseList,SetClauseList,([(String,Type)]),([TypeError]))
data Inh_SetClauseList = Inh_SetClauseList {cat_Inh_SetClauseList :: Catalog,lib_Inh_SetClauseList :: LocalIdentifierBindings}
data Syn_SetClauseList = Syn_SetClauseList {annotatedTree_Syn_SetClauseList :: SetClauseList,originalTree_Syn_SetClauseList :: SetClauseList,pairs_Syn_SetClauseList :: [(String,Type)],rowSetErrors_Syn_SetClauseList :: [TypeError]}
wrap_SetClauseList :: T_SetClauseList ->
Inh_SetClauseList ->
Syn_SetClauseList
wrap_SetClauseList sem (Inh_SetClauseList _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOpairs,_lhsOrowSetErrors) =
(sem _lhsIcat _lhsIlib )
in (Syn_SetClauseList _lhsOannotatedTree _lhsOoriginalTree _lhsOpairs _lhsOrowSetErrors ))
sem_SetClauseList_Cons :: T_SetClause ->
T_SetClauseList ->
T_SetClauseList
sem_SetClauseList_Cons hd_ tl_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOpairs :: ([(String,Type)])
_lhsOrowSetErrors :: ([TypeError])
_lhsOannotatedTree :: SetClauseList
_lhsOoriginalTree :: SetClauseList
_hdOcat :: Catalog
_hdOlib :: LocalIdentifierBindings
_tlOcat :: Catalog
_tlOlib :: LocalIdentifierBindings
_hdIannotatedTree :: SetClause
_hdIoriginalTree :: SetClause
_hdIpairs :: ([(String,Type)])
_hdIrowSetError :: (Maybe TypeError)
_tlIannotatedTree :: SetClauseList
_tlIoriginalTree :: SetClauseList
_tlIpairs :: ([(String,Type)])
_tlIrowSetErrors :: ([TypeError])
-- "./TypeChecking/Dml.ag"(line 142, column 10)
_lhsOpairs =
{-# LINE 142 "./TypeChecking/Dml.ag" #-}
_hdIpairs ++ _tlIpairs
{-# LINE 9066 "AstInternal.hs" #-}
-- "./TypeChecking/Dml.ag"(line 143, column 10)
_lhsOrowSetErrors =
{-# LINE 143 "./TypeChecking/Dml.ag" #-}
maybeToList _hdIrowSetError ++ _tlIrowSetErrors
{-# LINE 9071 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
(:) _hdIannotatedTree _tlIannotatedTree
{-# LINE 9076 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
(:) _hdIoriginalTree _tlIoriginalTree
{-# LINE 9081 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 9086 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 9091 "AstInternal.hs" #-}
-- copy rule (down)
_hdOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 9096 "AstInternal.hs" #-}
-- copy rule (down)
_hdOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 9101 "AstInternal.hs" #-}
-- copy rule (down)
_tlOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 9106 "AstInternal.hs" #-}
-- copy rule (down)
_tlOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 9111 "AstInternal.hs" #-}
( _hdIannotatedTree,_hdIoriginalTree,_hdIpairs,_hdIrowSetError) =
(hd_ _hdOcat _hdOlib )
( _tlIannotatedTree,_tlIoriginalTree,_tlIpairs,_tlIrowSetErrors) =
(tl_ _tlOcat _tlOlib )
in ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOpairs,_lhsOrowSetErrors)))
sem_SetClauseList_Nil :: T_SetClauseList
sem_SetClauseList_Nil =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOpairs :: ([(String,Type)])
_lhsOrowSetErrors :: ([TypeError])
_lhsOannotatedTree :: SetClauseList
_lhsOoriginalTree :: SetClauseList
-- "./TypeChecking/Dml.ag"(line 144, column 9)
_lhsOpairs =
{-# LINE 144 "./TypeChecking/Dml.ag" #-}
[]
{-# LINE 9129 "AstInternal.hs" #-}
-- "./TypeChecking/Dml.ag"(line 145, column 9)
_lhsOrowSetErrors =
{-# LINE 145 "./TypeChecking/Dml.ag" #-}
[]
{-# LINE 9134 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
[]
{-# LINE 9139 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
[]
{-# LINE 9144 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 9149 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 9154 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOpairs,_lhsOrowSetErrors)))
-- SetValue ----------------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
originalTree : SELF
alternatives:
alternative SetId:
child ann : {Annotation}
child string : {String}
visit 0:
local annotatedTree : _
local originalTree : _
alternative SetNum:
child ann : {Annotation}
child double : {Double}
visit 0:
local annotatedTree : _
local originalTree : _
alternative SetStr:
child ann : {Annotation}
child string : {String}
visit 0:
local annotatedTree : _
local originalTree : _
-}
data SetValue = SetId (Annotation) (String)
| SetNum (Annotation) (Double)
| SetStr (Annotation) (String)
deriving ( Data,Eq,Show,Typeable)
-- cata
sem_SetValue :: SetValue ->
T_SetValue
sem_SetValue (SetId _ann _string ) =
(sem_SetValue_SetId _ann _string )
sem_SetValue (SetNum _ann _double ) =
(sem_SetValue_SetNum _ann _double )
sem_SetValue (SetStr _ann _string ) =
(sem_SetValue_SetStr _ann _string )
-- semantic domain
type T_SetValue = Catalog ->
LocalIdentifierBindings ->
( SetValue,SetValue)
data Inh_SetValue = Inh_SetValue {cat_Inh_SetValue :: Catalog,lib_Inh_SetValue :: LocalIdentifierBindings}
data Syn_SetValue = Syn_SetValue {annotatedTree_Syn_SetValue :: SetValue,originalTree_Syn_SetValue :: SetValue}
wrap_SetValue :: T_SetValue ->
Inh_SetValue ->
Syn_SetValue
wrap_SetValue sem (Inh_SetValue _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_SetValue _lhsOannotatedTree _lhsOoriginalTree ))
sem_SetValue_SetId :: Annotation ->
String ->
T_SetValue
sem_SetValue_SetId ann_ string_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: SetValue
_lhsOoriginalTree :: SetValue
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
SetId ann_ string_
{-# LINE 9223 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
SetId ann_ string_
{-# LINE 9228 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 9233 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 9238 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
sem_SetValue_SetNum :: Annotation ->
Double ->
T_SetValue
sem_SetValue_SetNum ann_ double_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: SetValue
_lhsOoriginalTree :: SetValue
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
SetNum ann_ double_
{-# LINE 9252 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
SetNum ann_ double_
{-# LINE 9257 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 9262 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 9267 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
sem_SetValue_SetStr :: Annotation ->
String ->
T_SetValue
sem_SetValue_SetStr ann_ string_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: SetValue
_lhsOoriginalTree :: SetValue
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
SetStr ann_ string_
{-# LINE 9281 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
SetStr ann_ string_
{-# LINE 9286 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 9291 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 9296 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
-- Statement ---------------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
inProducedCat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
catUpdates : [CatalogUpdate]
libUpdates : [LocalIdentifierBindingsUpdate]
originalTree : SELF
alternatives:
alternative AlterSequence:
child ann : {Annotation}
child name : {String}
child ownedBy : {String}
visit 0:
local libUpdates : _
local annotatedTree : _
local originalTree : _
alternative AlterTable:
child ann : {Annotation}
child name : {String}
child actions : {[AlterTableAction]}
visit 0:
local annotatedTree : _
local originalTree : _
alternative Assignment:
child ann : {Annotation}
child target : {String}
child value : Expression
visit 0:
local libUpdates : _
local tpe : {Either [TypeError] Type}
local backTree : _
local catUpdates : {[CatalogUpdate]}
local statementType : _
local annotatedTree : _
local originalTree : _
alternative CaseStatement:
child ann : {Annotation}
child val : Expression
child cases : ExpressionListStatementListPairList
child els : StatementList
visit 0:
local annotatedTree : _
local originalTree : _
alternative ContinueStatement:
child ann : {Annotation}
visit 0:
local annotatedTree : _
local originalTree : _
alternative Copy:
child ann : {Annotation}
child table : {String}
child targetCols : StringList
child source : CopySource
visit 0:
local annotatedTree : _
local originalTree : _
alternative CopyData:
child ann : {Annotation}
child insData : {String}
visit 0:
local annotatedTree : _
local originalTree : _
alternative CreateDomain:
child ann : {Annotation}
child name : {String}
child typ : TypeName
child checkName : {String}
child check : MaybeBoolExpression
visit 0:
local libUpdates : _
local tpe : {Either [TypeError] Type}
local backTree : _
local statementType : _
local catUpdates : {[CatalogUpdate]}
local annotatedTree : _
local originalTree : _
alternative CreateFunction:
child ann : {Annotation}
child name : {String}
child params : ParamDefList
child rettype : TypeName
child lang : Language
child bodyQuote : {String}
child body : FnBody
child vol : Volatility
visit 0:
local libUpdates : _
local tpe : {Either [TypeError] Type}
local catUpdates : {[CatalogUpdate]}
local parameterTypes : _
local backTree : _
local statementType : _
local annotatedTree : _
local originalTree : _
alternative CreateLanguage:
child ann : {Annotation}
child name : {String}
visit 0:
local libUpdates : _
local tpe : {Either [TypeError] Type}
local backTree : _
local statementType : _
local catUpdates : {[CatalogUpdate]}
local annotatedTree : _
local originalTree : _
alternative CreateSequence:
child ann : {Annotation}
child name : {String}
child incr : {Integer}
child min : {Integer}
child max : {Integer}
child start : {Integer}
child cache : {Integer}
visit 0:
local libUpdates : _
local annotatedTree : _
local originalTree : _
alternative CreateTable:
child ann : {Annotation}
child name : {String}
child atts : AttributeDefList
child cons : ConstraintList
visit 0:
local libUpdates : _
local tpe : {Either [TypeError] Type}
local catUpdates : {[CatalogUpdate]}
local attrTypes : {[Type]}
local statementType : _
local backTree : _
local annotatedTree : _
local originalTree : _
alternative CreateTableAs:
child ann : {Annotation}
child name : {String}
child expr : SelectExpression
visit 0:
local libUpdates : _
local tpe : {Either [TypeError] Type}
local catUpdates : {[CatalogUpdate]}
local selType : _
local attrs : _
local backTree : _
local statementType : _
local annotatedTree : _
local originalTree : _
alternative CreateTrigger:
child ann : {Annotation}
child name : {String}
child wh : TriggerWhen
child events : {[TriggerEvent]}
child tbl : {String}
child firing : TriggerFire
child fnName : {String}
child fnArgs : {[Expression]}
visit 0:
local annotatedTree : _
local originalTree : _
alternative CreateType:
child ann : {Annotation}
child name : {String}
child atts : TypeAttributeDefList
visit 0:
local libUpdates : _
local tpe : {Either [TypeError] Type}
local backTree : _
local statementType : _
local catUpdates : {[CatalogUpdate]}
local annotatedTree : _
local originalTree : _
alternative CreateView:
child ann : {Annotation}
child name : {String}
child expr : SelectExpression
visit 0:
local libUpdates : _
local tpe : {Either [TypeError] Type}
local backTree : _
local attrs : _
local catUpdates : {[CatalogUpdate]}
local statementType : _
local annotatedTree : _
local originalTree : _
alternative Delete:
child ann : {Annotation}
child table : {String}
child whr : MaybeBoolExpression
child returning : MaybeSelectList
visit 0:
local libUpdates : _
local tpe : {Either [TypeError] Type}
local statementType : _
local backTree : _
local catUpdates : {[CatalogUpdate]}
local lib : _
local annotatedTree : _
local originalTree : _
alternative DropFunction:
child ann : {Annotation}
child ifE : IfExists
child sigs : StringTypeNameListPairList
child cascade : Cascade
visit 0:
local libUpdates : _
local tpe : {Either [TypeError] Type}
local backTree : _
local catUpdates : {[CatalogUpdate]}
local statementType : _
local annotatedTree : _
local originalTree : _
alternative DropSomething:
child ann : {Annotation}
child dropType : DropType
child ifE : IfExists
child names : StringList
child cascade : Cascade
visit 0:
local annotatedTree : _
local originalTree : _
alternative Execute:
child ann : {Annotation}
child expr : Expression
visit 0:
local annotatedTree : _
local originalTree : _
alternative ExecuteInto:
child ann : {Annotation}
child expr : Expression
child targets : StringList
visit 0:
local annotatedTree : _
local originalTree : _
alternative ForIntegerStatement:
child ann : {Annotation}
child var : {String}
child from : Expression
child to : Expression
child sts : StatementList
visit 0:
local libUpdates : _
local varTypeE : _
local tpe : {Either [TypeError] Type}
local backTree : _
local catUpdates : {[CatalogUpdate]}
local statementType : _
local annotatedTree : _
local originalTree : _
alternative ForSelectStatement:
child ann : {Annotation}
child var : {String}
child sel : SelectExpression
child sts : StatementList
visit 0:
local libUpdates : _
local selType : _
local tpe : {Either [TypeError] Type}
local backTree : _
local catUpdates : {[CatalogUpdate]}
local statementType : _
local annotatedTree : _
local originalTree : _
alternative If:
child ann : {Annotation}
child cases : ExpressionStatementListPairList
child els : StatementList
visit 0:
local annotatedTree : _
local originalTree : _
alternative Insert:
child ann : {Annotation}
child table : {String}
child targetCols : StringList
child insData : SelectExpression
child returning : MaybeSelectList
visit 0:
local libUpdates : _
local tpe : {Either [TypeError] Type}
local statementType : _
local columnTypes : _
local insDataAddedInferredTypes : _
local backTree : _
local catUpdates : {[CatalogUpdate]}
local annotatedTree : _
local originalTree : _
alternative Notify:
child ann : {Annotation}
child name : {String}
visit 0:
local libUpdates : _
local annotatedTree : _
local originalTree : _
alternative NullStatement:
child ann : {Annotation}
visit 0:
local annotatedTree : _
local originalTree : _
alternative Perform:
child ann : {Annotation}
child expr : Expression
visit 0:
local annotatedTree : _
local originalTree : _
alternative Raise:
child ann : {Annotation}
child level : RaiseType
child message : {String}
child args : ExpressionList
visit 0:
local annotatedTree : _
local originalTree : _
alternative Return:
child ann : {Annotation}
child value : MaybeExpression
visit 0:
local libUpdates : _
local tpe : {Either [TypeError] Type}
local backTree : _
local catUpdates : {[CatalogUpdate]}
local statementType : _
local annotatedTree : _
local originalTree : _
alternative ReturnNext:
child ann : {Annotation}
child expr : Expression
visit 0:
local annotatedTree : _
local originalTree : _
alternative ReturnQuery:
child ann : {Annotation}
child sel : SelectExpression
visit 0:
local annotatedTree : _
local originalTree : _
alternative SelectStatement:
child ann : {Annotation}
child ex : SelectExpression
visit 0:
local tpe : {Either [TypeError] Type}
local statementType : _
local backTree : _
local catUpdates : {[CatalogUpdate]}
local libUpdates : _
local annotatedTree : _
local originalTree : _
alternative Set:
child ann : {Annotation}
child name : {String}
child values : {[SetValue]}
visit 0:
local libUpdates : _
local annotatedTree : _
local originalTree : _
alternative Truncate:
child ann : {Annotation}
child tables : StringList
child restartIdentity : RestartIdentity
child cascade : Cascade
visit 0:
local annotatedTree : _
local originalTree : _
alternative Update:
child ann : {Annotation}
child table : {String}
child assigns : SetClauseList
child whr : MaybeBoolExpression
child returning : MaybeSelectList
visit 0:
local libUpdates : _
local tpe : {Either [TypeError] Type}
local statementType : _
local columnTypes : _
local assignWInferredTypes : {SetClauseList}
local backTree : _
local catUpdates : {[CatalogUpdate]}
local lib : _
local annotatedTree : _
local originalTree : _
alternative WhileStatement:
child ann : {Annotation}
child expr : Expression
child sts : StatementList
visit 0:
local annotatedTree : _
local originalTree : _
-}
data Statement = AlterSequence (Annotation) (String) (String)
| AlterTable (Annotation) (String) ([AlterTableAction])
| Assignment (Annotation) (String) (Expression)
| CaseStatement (Annotation) (Expression) (ExpressionListStatementListPairList) (StatementList)
| ContinueStatement (Annotation)
| Copy (Annotation) (String) (StringList) (CopySource)
| CopyData (Annotation) (String)
| CreateDomain (Annotation) (String) (TypeName) (String) (MaybeBoolExpression)
| CreateFunction (Annotation) (String) (ParamDefList) (TypeName) (Language) (String) (FnBody) (Volatility)
| CreateLanguage (Annotation) (String)
| CreateSequence (Annotation) (String) (Integer) (Integer) (Integer) (Integer) (Integer)
| CreateTable (Annotation) (String) (AttributeDefList) (ConstraintList)
| CreateTableAs (Annotation) (String) (SelectExpression)
| CreateTrigger (Annotation) (String) (TriggerWhen) ([TriggerEvent]) (String) (TriggerFire) (String) ([Expression])
| CreateType (Annotation) (String) (TypeAttributeDefList)
| CreateView (Annotation) (String) (SelectExpression)
| Delete (Annotation) (String) (MaybeBoolExpression) (MaybeSelectList)
| DropFunction (Annotation) (IfExists) (StringTypeNameListPairList) (Cascade)
| DropSomething (Annotation) (DropType) (IfExists) (StringList) (Cascade)
| Execute (Annotation) (Expression)
| ExecuteInto (Annotation) (Expression) (StringList)
| ForIntegerStatement (Annotation) (String) (Expression) (Expression) (StatementList)
| ForSelectStatement (Annotation) (String) (SelectExpression) (StatementList)
| If (Annotation) (ExpressionStatementListPairList) (StatementList)
| Insert (Annotation) (String) (StringList) (SelectExpression) (MaybeSelectList)
| Notify (Annotation) (String)
| NullStatement (Annotation)
| Perform (Annotation) (Expression)
| Raise (Annotation) (RaiseType) (String) (ExpressionList)
| Return (Annotation) (MaybeExpression)
| ReturnNext (Annotation) (Expression)
| ReturnQuery (Annotation) (SelectExpression)
| SelectStatement (Annotation) (SelectExpression)
| Set (Annotation) (String) ([SetValue])
| Truncate (Annotation) (StringList) (RestartIdentity) (Cascade)
| Update (Annotation) (String) (SetClauseList) (MaybeBoolExpression) (MaybeSelectList)
| WhileStatement (Annotation) (Expression) (StatementList)
deriving ( Data,Eq,Show,Typeable)
-- cata
sem_Statement :: Statement ->
T_Statement
sem_Statement (AlterSequence _ann _name _ownedBy ) =
(sem_Statement_AlterSequence _ann _name _ownedBy )
sem_Statement (AlterTable _ann _name _actions ) =
(sem_Statement_AlterTable _ann _name _actions )
sem_Statement (Assignment _ann _target _value ) =
(sem_Statement_Assignment _ann _target (sem_Expression _value ) )
sem_Statement (CaseStatement _ann _val _cases _els ) =
(sem_Statement_CaseStatement _ann (sem_Expression _val ) (sem_ExpressionListStatementListPairList _cases ) (sem_StatementList _els ) )
sem_Statement (ContinueStatement _ann ) =
(sem_Statement_ContinueStatement _ann )
sem_Statement (Copy _ann _table _targetCols _source ) =
(sem_Statement_Copy _ann _table (sem_StringList _targetCols ) (sem_CopySource _source ) )
sem_Statement (CopyData _ann _insData ) =
(sem_Statement_CopyData _ann _insData )
sem_Statement (CreateDomain _ann _name _typ _checkName _check ) =
(sem_Statement_CreateDomain _ann _name (sem_TypeName _typ ) _checkName (sem_MaybeBoolExpression _check ) )
sem_Statement (CreateFunction _ann _name _params _rettype _lang _bodyQuote _body _vol ) =
(sem_Statement_CreateFunction _ann _name (sem_ParamDefList _params ) (sem_TypeName _rettype ) (sem_Language _lang ) _bodyQuote (sem_FnBody _body ) (sem_Volatility _vol ) )
sem_Statement (CreateLanguage _ann _name ) =
(sem_Statement_CreateLanguage _ann _name )
sem_Statement (CreateSequence _ann _name _incr _min _max _start _cache ) =
(sem_Statement_CreateSequence _ann _name _incr _min _max _start _cache )
sem_Statement (CreateTable _ann _name _atts _cons ) =
(sem_Statement_CreateTable _ann _name (sem_AttributeDefList _atts ) (sem_ConstraintList _cons ) )
sem_Statement (CreateTableAs _ann _name _expr ) =
(sem_Statement_CreateTableAs _ann _name (sem_SelectExpression _expr ) )
sem_Statement (CreateTrigger _ann _name _wh _events _tbl _firing _fnName _fnArgs ) =
(sem_Statement_CreateTrigger _ann _name (sem_TriggerWhen _wh ) _events _tbl (sem_TriggerFire _firing ) _fnName _fnArgs )
sem_Statement (CreateType _ann _name _atts ) =
(sem_Statement_CreateType _ann _name (sem_TypeAttributeDefList _atts ) )
sem_Statement (CreateView _ann _name _expr ) =
(sem_Statement_CreateView _ann _name (sem_SelectExpression _expr ) )
sem_Statement (Delete _ann _table _whr _returning ) =
(sem_Statement_Delete _ann _table (sem_MaybeBoolExpression _whr ) (sem_MaybeSelectList _returning ) )
sem_Statement (DropFunction _ann _ifE _sigs _cascade ) =
(sem_Statement_DropFunction _ann (sem_IfExists _ifE ) (sem_StringTypeNameListPairList _sigs ) (sem_Cascade _cascade ) )
sem_Statement (DropSomething _ann _dropType _ifE _names _cascade ) =
(sem_Statement_DropSomething _ann (sem_DropType _dropType ) (sem_IfExists _ifE ) (sem_StringList _names ) (sem_Cascade _cascade ) )
sem_Statement (Execute _ann _expr ) =
(sem_Statement_Execute _ann (sem_Expression _expr ) )
sem_Statement (ExecuteInto _ann _expr _targets ) =
(sem_Statement_ExecuteInto _ann (sem_Expression _expr ) (sem_StringList _targets ) )
sem_Statement (ForIntegerStatement _ann _var _from _to _sts ) =
(sem_Statement_ForIntegerStatement _ann _var (sem_Expression _from ) (sem_Expression _to ) (sem_StatementList _sts ) )
sem_Statement (ForSelectStatement _ann _var _sel _sts ) =
(sem_Statement_ForSelectStatement _ann _var (sem_SelectExpression _sel ) (sem_StatementList _sts ) )
sem_Statement (If _ann _cases _els ) =
(sem_Statement_If _ann (sem_ExpressionStatementListPairList _cases ) (sem_StatementList _els ) )
sem_Statement (Insert _ann _table _targetCols _insData _returning ) =
(sem_Statement_Insert _ann _table (sem_StringList _targetCols ) (sem_SelectExpression _insData ) (sem_MaybeSelectList _returning ) )
sem_Statement (Notify _ann _name ) =
(sem_Statement_Notify _ann _name )
sem_Statement (NullStatement _ann ) =
(sem_Statement_NullStatement _ann )
sem_Statement (Perform _ann _expr ) =
(sem_Statement_Perform _ann (sem_Expression _expr ) )
sem_Statement (Raise _ann _level _message _args ) =
(sem_Statement_Raise _ann (sem_RaiseType _level ) _message (sem_ExpressionList _args ) )
sem_Statement (Return _ann _value ) =
(sem_Statement_Return _ann (sem_MaybeExpression _value ) )
sem_Statement (ReturnNext _ann _expr ) =
(sem_Statement_ReturnNext _ann (sem_Expression _expr ) )
sem_Statement (ReturnQuery _ann _sel ) =
(sem_Statement_ReturnQuery _ann (sem_SelectExpression _sel ) )
sem_Statement (SelectStatement _ann _ex ) =
(sem_Statement_SelectStatement _ann (sem_SelectExpression _ex ) )
sem_Statement (Set _ann _name _values ) =
(sem_Statement_Set _ann _name _values )
sem_Statement (Truncate _ann _tables _restartIdentity _cascade ) =
(sem_Statement_Truncate _ann (sem_StringList _tables ) (sem_RestartIdentity _restartIdentity ) (sem_Cascade _cascade ) )
sem_Statement (Update _ann _table _assigns _whr _returning ) =
(sem_Statement_Update _ann _table (sem_SetClauseList _assigns ) (sem_MaybeBoolExpression _whr ) (sem_MaybeSelectList _returning ) )
sem_Statement (WhileStatement _ann _expr _sts ) =
(sem_Statement_WhileStatement _ann (sem_Expression _expr ) (sem_StatementList _sts ) )
-- semantic domain
type T_Statement = Catalog ->
Catalog ->
LocalIdentifierBindings ->
( Statement,([CatalogUpdate]),([LocalIdentifierBindingsUpdate]),Statement)
data Inh_Statement = Inh_Statement {cat_Inh_Statement :: Catalog,inProducedCat_Inh_Statement :: Catalog,lib_Inh_Statement :: LocalIdentifierBindings}
data Syn_Statement = Syn_Statement {annotatedTree_Syn_Statement :: Statement,catUpdates_Syn_Statement :: [CatalogUpdate],libUpdates_Syn_Statement :: [LocalIdentifierBindingsUpdate],originalTree_Syn_Statement :: Statement}
wrap_Statement :: T_Statement ->
Inh_Statement ->
Syn_Statement
wrap_Statement sem (Inh_Statement _lhsIcat _lhsIinProducedCat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIinProducedCat _lhsIlib )
in (Syn_Statement _lhsOannotatedTree _lhsOcatUpdates _lhsOlibUpdates _lhsOoriginalTree ))
sem_Statement_AlterSequence :: Annotation ->
String ->
String ->
T_Statement
sem_Statement_AlterSequence ann_ name_ ownedBy_ =
(\ _lhsIcat
_lhsIinProducedCat
_lhsIlib ->
(let _lhsOcatUpdates :: ([CatalogUpdate])
_lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_lhsOannotatedTree :: Statement
_lhsOoriginalTree :: Statement
-- "./TypeChecking/Statements.ag"(line 73, column 9)
_libUpdates =
{-# LINE 73 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 9832 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 89, column 9)
_lhsOcatUpdates =
{-# LINE 89 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 9837 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 90, column 9)
_lhsOlibUpdates =
{-# LINE 90 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 9842 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
AlterSequence ann_ name_ ownedBy_
{-# LINE 9847 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
AlterSequence ann_ name_ ownedBy_
{-# LINE 9852 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 9857 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 9862 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree)))
sem_Statement_AlterTable :: Annotation ->
String ->
([AlterTableAction]) ->
T_Statement
sem_Statement_AlterTable ann_ name_ actions_ =
(\ _lhsIcat
_lhsIinProducedCat
_lhsIlib ->
(let _lhsOcatUpdates :: ([CatalogUpdate])
_lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_lhsOannotatedTree :: Statement
_lhsOoriginalTree :: Statement
-- "./TypeChecking/Statements.ag"(line 89, column 9)
_lhsOcatUpdates =
{-# LINE 89 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 9880 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 90, column 9)
_lhsOlibUpdates =
{-# LINE 90 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 9885 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
AlterTable ann_ name_ actions_
{-# LINE 9890 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
AlterTable ann_ name_ actions_
{-# LINE 9895 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 9900 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 9905 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree)))
sem_Statement_Assignment :: Annotation ->
String ->
T_Expression ->
T_Statement
sem_Statement_Assignment ann_ target_ value_ =
(\ _lhsIcat
_lhsIinProducedCat
_lhsIlib ->
(let _lhsOannotatedTree :: Statement
_lhsOcatUpdates :: ([CatalogUpdate])
_lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_tpe :: (Either [TypeError] Type)
_catUpdates :: ([CatalogUpdate])
_lhsOoriginalTree :: Statement
_valueOcat :: Catalog
_valueOlib :: LocalIdentifierBindings
_valueIannotatedTree :: Expression
_valueIliftedColumnName :: String
_valueIoriginalTree :: Expression
-- "./TypeChecking/Statements.ag"(line 61, column 9)
_lhsOannotatedTree =
{-# LINE 61 "./TypeChecking/Statements.ag" #-}
annTypesAndErrors _backTree
(tpeToT _tpe )
(getErrors _tpe )
$ Just (map StatementTypeA _statementType ++
[CatUpdates _catUpdates ])
{-# LINE 9934 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 67, column 9)
_lhsOcatUpdates =
{-# LINE 67 "./TypeChecking/Statements.ag" #-}
_catUpdates
{-# LINE 9939 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 68, column 9)
_lhsOlibUpdates =
{-# LINE 68 "./TypeChecking/Statements.ag" #-}
_libUpdates
{-# LINE 9944 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 73, column 9)
_libUpdates =
{-# LINE 73 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 9949 "AstInternal.hs" #-}
-- "./TypeChecking/Plpgsql.ag"(line 23, column 9)
_tpe =
{-# LINE 23 "./TypeChecking/Plpgsql.ag" #-}
do
let fromType = getTypeAnnotation _valueIannotatedTree
toType <- libLookupID _lhsIlib target_
dependsOnRTpe [getTypeAnnotation _valueIannotatedTree, toType] $ do
checkAssignmentValid _lhsIcat fromType toType
return $ Pseudo Void
{-# LINE 9959 "AstInternal.hs" #-}
-- "./TypeChecking/Plpgsql.ag"(line 30, column 9)
_backTree =
{-# LINE 30 "./TypeChecking/Plpgsql.ag" #-}
Assignment ann_ target_ _valueIannotatedTree
{-# LINE 9964 "AstInternal.hs" #-}
-- "./TypeChecking/Plpgsql.ag"(line 31, column 9)
_catUpdates =
{-# LINE 31 "./TypeChecking/Plpgsql.ag" #-}
[]
{-# LINE 9969 "AstInternal.hs" #-}
-- "./TypeChecking/Plpgsql.ag"(line 32, column 9)
_statementType =
{-# LINE 32 "./TypeChecking/Plpgsql.ag" #-}
[]
{-# LINE 9974 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
Assignment ann_ target_ _valueIannotatedTree
{-# LINE 9979 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
Assignment ann_ target_ _valueIoriginalTree
{-# LINE 9984 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 9989 "AstInternal.hs" #-}
-- copy rule (down)
_valueOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 9994 "AstInternal.hs" #-}
-- copy rule (down)
_valueOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 9999 "AstInternal.hs" #-}
( _valueIannotatedTree,_valueIliftedColumnName,_valueIoriginalTree) =
(value_ _valueOcat _valueOlib )
in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree)))
sem_Statement_CaseStatement :: Annotation ->
T_Expression ->
T_ExpressionListStatementListPairList ->
T_StatementList ->
T_Statement
sem_Statement_CaseStatement ann_ val_ cases_ els_ =
(\ _lhsIcat
_lhsIinProducedCat
_lhsIlib ->
(let _lhsOcatUpdates :: ([CatalogUpdate])
_lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_elsOcatUpdates :: ([CatalogUpdate])
_elsOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_lhsOannotatedTree :: Statement
_lhsOoriginalTree :: Statement
_valOcat :: Catalog
_valOlib :: LocalIdentifierBindings
_casesOcat :: Catalog
_casesOlib :: LocalIdentifierBindings
_elsOcat :: Catalog
_elsOlib :: LocalIdentifierBindings
_valIannotatedTree :: Expression
_valIliftedColumnName :: String
_valIoriginalTree :: Expression
_casesIannotatedTree :: ExpressionListStatementListPairList
_casesIoriginalTree :: ExpressionListStatementListPairList
_elsIannotatedTree :: StatementList
_elsIoriginalTree :: StatementList
_elsIproducedCat :: Catalog
_elsIproducedLib :: LocalIdentifierBindings
-- "./TypeChecking/Statements.ag"(line 89, column 9)
_lhsOcatUpdates =
{-# LINE 89 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 10037 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 90, column 9)
_lhsOlibUpdates =
{-# LINE 90 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 10042 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 106, column 9)
_elsOcatUpdates =
{-# LINE 106 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 10047 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 107, column 9)
_elsOlibUpdates =
{-# LINE 107 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 10052 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
CaseStatement ann_ _valIannotatedTree _casesIannotatedTree _elsIannotatedTree
{-# LINE 10057 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
CaseStatement ann_ _valIoriginalTree _casesIoriginalTree _elsIoriginalTree
{-# LINE 10062 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 10067 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 10072 "AstInternal.hs" #-}
-- copy rule (down)
_valOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 10077 "AstInternal.hs" #-}
-- copy rule (down)
_valOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 10082 "AstInternal.hs" #-}
-- copy rule (down)
_casesOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 10087 "AstInternal.hs" #-}
-- copy rule (down)
_casesOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 10092 "AstInternal.hs" #-}
-- copy rule (down)
_elsOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 10097 "AstInternal.hs" #-}
-- copy rule (down)
_elsOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 10102 "AstInternal.hs" #-}
( _valIannotatedTree,_valIliftedColumnName,_valIoriginalTree) =
(val_ _valOcat _valOlib )
( _casesIannotatedTree,_casesIoriginalTree) =
(cases_ _casesOcat _casesOlib )
( _elsIannotatedTree,_elsIoriginalTree,_elsIproducedCat,_elsIproducedLib) =
(els_ _elsOcat _elsOcatUpdates _elsOlib _elsOlibUpdates )
in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree)))
sem_Statement_ContinueStatement :: Annotation ->
T_Statement
sem_Statement_ContinueStatement ann_ =
(\ _lhsIcat
_lhsIinProducedCat
_lhsIlib ->
(let _lhsOcatUpdates :: ([CatalogUpdate])
_lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_lhsOannotatedTree :: Statement
_lhsOoriginalTree :: Statement
-- "./TypeChecking/Statements.ag"(line 89, column 9)
_lhsOcatUpdates =
{-# LINE 89 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 10124 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 90, column 9)
_lhsOlibUpdates =
{-# LINE 90 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 10129 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
ContinueStatement ann_
{-# LINE 10134 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
ContinueStatement ann_
{-# LINE 10139 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 10144 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 10149 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree)))
sem_Statement_Copy :: Annotation ->
String ->
T_StringList ->
T_CopySource ->
T_Statement
sem_Statement_Copy ann_ table_ targetCols_ source_ =
(\ _lhsIcat
_lhsIinProducedCat
_lhsIlib ->
(let _lhsOcatUpdates :: ([CatalogUpdate])
_lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_lhsOannotatedTree :: Statement
_lhsOoriginalTree :: Statement
_targetColsOcat :: Catalog
_targetColsOlib :: LocalIdentifierBindings
_sourceOcat :: Catalog
_sourceOlib :: LocalIdentifierBindings
_targetColsIannotatedTree :: StringList
_targetColsIoriginalTree :: StringList
_targetColsIstrings :: ([String])
_sourceIannotatedTree :: CopySource
_sourceIoriginalTree :: CopySource
-- "./TypeChecking/Statements.ag"(line 89, column 9)
_lhsOcatUpdates =
{-# LINE 89 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 10177 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 90, column 9)
_lhsOlibUpdates =
{-# LINE 90 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 10182 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
Copy ann_ table_ _targetColsIannotatedTree _sourceIannotatedTree
{-# LINE 10187 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
Copy ann_ table_ _targetColsIoriginalTree _sourceIoriginalTree
{-# LINE 10192 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 10197 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 10202 "AstInternal.hs" #-}
-- copy rule (down)
_targetColsOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 10207 "AstInternal.hs" #-}
-- copy rule (down)
_targetColsOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 10212 "AstInternal.hs" #-}
-- copy rule (down)
_sourceOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 10217 "AstInternal.hs" #-}
-- copy rule (down)
_sourceOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 10222 "AstInternal.hs" #-}
( _targetColsIannotatedTree,_targetColsIoriginalTree,_targetColsIstrings) =
(targetCols_ _targetColsOcat _targetColsOlib )
( _sourceIannotatedTree,_sourceIoriginalTree) =
(source_ _sourceOcat _sourceOlib )
in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree)))
sem_Statement_CopyData :: Annotation ->
String ->
T_Statement
sem_Statement_CopyData ann_ insData_ =
(\ _lhsIcat
_lhsIinProducedCat
_lhsIlib ->
(let _lhsOcatUpdates :: ([CatalogUpdate])
_lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_lhsOannotatedTree :: Statement
_lhsOoriginalTree :: Statement
-- "./TypeChecking/Statements.ag"(line 89, column 9)
_lhsOcatUpdates =
{-# LINE 89 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 10243 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 90, column 9)
_lhsOlibUpdates =
{-# LINE 90 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 10248 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
CopyData ann_ insData_
{-# LINE 10253 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
CopyData ann_ insData_
{-# LINE 10258 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 10263 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 10268 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree)))
sem_Statement_CreateDomain :: Annotation ->
String ->
T_TypeName ->
String ->
T_MaybeBoolExpression ->
T_Statement
sem_Statement_CreateDomain ann_ name_ typ_ checkName_ check_ =
(\ _lhsIcat
_lhsIinProducedCat
_lhsIlib ->
(let _lhsOannotatedTree :: Statement
_lhsOcatUpdates :: ([CatalogUpdate])
_lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_tpe :: (Either [TypeError] Type)
_catUpdates :: ([CatalogUpdate])
_checkOlib :: LocalIdentifierBindings
_lhsOoriginalTree :: Statement
_typOcat :: Catalog
_typOlib :: LocalIdentifierBindings
_checkOcat :: Catalog
_typIannotatedTree :: TypeName
_typInamedType :: Type
_typIoriginalTree :: TypeName
_checkIannotatedTree :: MaybeBoolExpression
_checkIoriginalTree :: MaybeBoolExpression
-- "./TypeChecking/Statements.ag"(line 61, column 9)
_lhsOannotatedTree =
{-# LINE 61 "./TypeChecking/Statements.ag" #-}
annTypesAndErrors _backTree
(tpeToT _tpe )
(getErrors _tpe )
$ Just (map StatementTypeA _statementType ++
[CatUpdates _catUpdates ])
{-# LINE 10303 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 67, column 9)
_lhsOcatUpdates =
{-# LINE 67 "./TypeChecking/Statements.ag" #-}
_catUpdates
{-# LINE 10308 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 68, column 9)
_lhsOlibUpdates =
{-# LINE 68 "./TypeChecking/Statements.ag" #-}
_libUpdates
{-# LINE 10313 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 73, column 9)
_libUpdates =
{-# LINE 73 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 10318 "AstInternal.hs" #-}
-- "./TypeChecking/MiscCreates.ag"(line 64, column 9)
_tpe =
{-# LINE 64 "./TypeChecking/MiscCreates.ag" #-}
Right $ Pseudo Void
{-# LINE 10323 "AstInternal.hs" #-}
-- "./TypeChecking/MiscCreates.ag"(line 65, column 9)
_backTree =
{-# LINE 65 "./TypeChecking/MiscCreates.ag" #-}
CreateDomain ann_ name_ _typIannotatedTree checkName_ _checkIannotatedTree
{-# LINE 10328 "AstInternal.hs" #-}
-- "./TypeChecking/MiscCreates.ag"(line 66, column 9)
_statementType =
{-# LINE 66 "./TypeChecking/MiscCreates.ag" #-}
[]
{-# LINE 10333 "AstInternal.hs" #-}
-- "./TypeChecking/MiscCreates.ag"(line 67, column 9)
_catUpdates =
{-# LINE 67 "./TypeChecking/MiscCreates.ag" #-}
[CatCreateDomain (DomainType name_) _typInamedType]
{-# LINE 10338 "AstInternal.hs" #-}
-- "./TypeChecking/MiscCreates.ag"(line 69, column 9)
_checkOlib =
{-# LINE 69 "./TypeChecking/MiscCreates.ag" #-}
fromRight _lhsIlib $
updateBindings _lhsIlib _lhsIcat
[LibStackIDs [("", [("value", _typInamedType)])]]
{-# LINE 10345 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
CreateDomain ann_ name_ _typIannotatedTree checkName_ _checkIannotatedTree
{-# LINE 10350 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
CreateDomain ann_ name_ _typIoriginalTree checkName_ _checkIoriginalTree
{-# LINE 10355 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 10360 "AstInternal.hs" #-}
-- copy rule (down)
_typOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 10365 "AstInternal.hs" #-}
-- copy rule (down)
_typOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 10370 "AstInternal.hs" #-}
-- copy rule (down)
_checkOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 10375 "AstInternal.hs" #-}
( _typIannotatedTree,_typInamedType,_typIoriginalTree) =
(typ_ _typOcat _typOlib )
( _checkIannotatedTree,_checkIoriginalTree) =
(check_ _checkOcat _checkOlib )
in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree)))
sem_Statement_CreateFunction :: Annotation ->
String ->
T_ParamDefList ->
T_TypeName ->
T_Language ->
String ->
T_FnBody ->
T_Volatility ->
T_Statement
sem_Statement_CreateFunction ann_ name_ params_ rettype_ lang_ bodyQuote_ body_ vol_ =
(\ _lhsIcat
_lhsIinProducedCat
_lhsIlib ->
(let _lhsOannotatedTree :: Statement
_lhsOcatUpdates :: ([CatalogUpdate])
_lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_tpe :: (Either [TypeError] Type)
_catUpdates :: ([CatalogUpdate])
_bodyOcat :: Catalog
_bodyOlib :: LocalIdentifierBindings
_lhsOoriginalTree :: Statement
_paramsOcat :: Catalog
_paramsOlib :: LocalIdentifierBindings
_rettypeOcat :: Catalog
_rettypeOlib :: LocalIdentifierBindings
_langOcat :: Catalog
_langOlib :: LocalIdentifierBindings
_volOcat :: Catalog
_volOlib :: LocalIdentifierBindings
_paramsIannotatedTree :: ParamDefList
_paramsIoriginalTree :: ParamDefList
_paramsIparams :: ([(String, Type)])
_rettypeIannotatedTree :: TypeName
_rettypeInamedType :: Type
_rettypeIoriginalTree :: TypeName
_langIannotatedTree :: Language
_langIoriginalTree :: Language
_bodyIannotatedTree :: FnBody
_bodyIoriginalTree :: FnBody
_volIannotatedTree :: Volatility
_volIoriginalTree :: Volatility
-- "./TypeChecking/Statements.ag"(line 61, column 9)
_lhsOannotatedTree =
{-# LINE 61 "./TypeChecking/Statements.ag" #-}
annTypesAndErrors _backTree
(tpeToT _tpe )
(getErrors _tpe )
$ Just (map StatementTypeA _statementType ++
[CatUpdates _catUpdates ])
{-# LINE 10430 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 67, column 9)
_lhsOcatUpdates =
{-# LINE 67 "./TypeChecking/Statements.ag" #-}
_catUpdates
{-# LINE 10435 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 68, column 9)
_lhsOlibUpdates =
{-# LINE 68 "./TypeChecking/Statements.ag" #-}
_libUpdates
{-# LINE 10440 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 73, column 9)
_libUpdates =
{-# LINE 73 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 10445 "AstInternal.hs" #-}
-- "./TypeChecking/CreateFunction.ag"(line 23, column 9)
_tpe =
{-# LINE 23 "./TypeChecking/CreateFunction.ag" #-}
dependsOnRTpe
(_rettypeInamedType : _parameterTypes ) $
Right $ Pseudo Void
{-# LINE 10452 "AstInternal.hs" #-}
-- "./TypeChecking/CreateFunction.ag"(line 26, column 9)
_catUpdates =
{-# LINE 26 "./TypeChecking/CreateFunction.ag" #-}
dependsOn [tpeToT _tpe ] []
[CatCreateFunction FunName
(map toLower name_)
_parameterTypes
_rettypeInamedType
False]
{-# LINE 10462 "AstInternal.hs" #-}
-- "./TypeChecking/CreateFunction.ag"(line 32, column 9)
_parameterTypes =
{-# LINE 32 "./TypeChecking/CreateFunction.ag" #-}
(map snd _paramsIparams)
{-# LINE 10467 "AstInternal.hs" #-}
-- "./TypeChecking/CreateFunction.ag"(line 34, column 9)
_backTree =
{-# LINE 34 "./TypeChecking/CreateFunction.ag" #-}
CreateFunction ann_
name_
_paramsIannotatedTree
_rettypeIannotatedTree
_langIannotatedTree
bodyQuote_
_bodyIannotatedTree
_volIannotatedTree
{-# LINE 10479 "AstInternal.hs" #-}
-- "./TypeChecking/CreateFunction.ag"(line 42, column 9)
_statementType =
{-# LINE 42 "./TypeChecking/CreateFunction.ag" #-}
[]
{-# LINE 10484 "AstInternal.hs" #-}
-- "./TypeChecking/CreateFunction.ag"(line 43, column 9)
_bodyOcat =
{-# LINE 43 "./TypeChecking/CreateFunction.ag" #-}
_lhsIinProducedCat
{-# LINE 10489 "AstInternal.hs" #-}
-- "./TypeChecking/CreateFunction.ag"(line 99, column 9)
_bodyOlib =
{-# LINE 99 "./TypeChecking/CreateFunction.ag" #-}
let p = _paramsIparams
++ (zip posNames $ map snd _paramsIparams)
in fromRight _lhsIlib $
updateBindings _lhsIlib _lhsIcat
[LibStackIDs [("", p)
,(name_, _paramsIparams)]]
where
posNames :: [String]
posNames = map (\l -> '$':show l) [1..]
{-# LINE 10502 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
CreateFunction ann_ name_ _paramsIannotatedTree _rettypeIannotatedTree _langIannotatedTree bodyQuote_ _bodyIannotatedTree _volIannotatedTree
{-# LINE 10507 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
CreateFunction ann_ name_ _paramsIoriginalTree _rettypeIoriginalTree _langIoriginalTree bodyQuote_ _bodyIoriginalTree _volIoriginalTree
{-# LINE 10512 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 10517 "AstInternal.hs" #-}
-- copy rule (down)
_paramsOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 10522 "AstInternal.hs" #-}
-- copy rule (down)
_paramsOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 10527 "AstInternal.hs" #-}
-- copy rule (down)
_rettypeOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 10532 "AstInternal.hs" #-}
-- copy rule (down)
_rettypeOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 10537 "AstInternal.hs" #-}
-- copy rule (down)
_langOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 10542 "AstInternal.hs" #-}
-- copy rule (down)
_langOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 10547 "AstInternal.hs" #-}
-- copy rule (down)
_volOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 10552 "AstInternal.hs" #-}
-- copy rule (down)
_volOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 10557 "AstInternal.hs" #-}
( _paramsIannotatedTree,_paramsIoriginalTree,_paramsIparams) =
(params_ _paramsOcat _paramsOlib )
( _rettypeIannotatedTree,_rettypeInamedType,_rettypeIoriginalTree) =
(rettype_ _rettypeOcat _rettypeOlib )
( _langIannotatedTree,_langIoriginalTree) =
(lang_ _langOcat _langOlib )
( _bodyIannotatedTree,_bodyIoriginalTree) =
(body_ _bodyOcat _bodyOlib )
( _volIannotatedTree,_volIoriginalTree) =
(vol_ _volOcat _volOlib )
in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree)))
sem_Statement_CreateLanguage :: Annotation ->
String ->
T_Statement
sem_Statement_CreateLanguage ann_ name_ =
(\ _lhsIcat
_lhsIinProducedCat
_lhsIlib ->
(let _lhsOannotatedTree :: Statement
_lhsOcatUpdates :: ([CatalogUpdate])
_lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_tpe :: (Either [TypeError] Type)
_catUpdates :: ([CatalogUpdate])
_lhsOoriginalTree :: Statement
-- "./TypeChecking/Statements.ag"(line 61, column 9)
_lhsOannotatedTree =
{-# LINE 61 "./TypeChecking/Statements.ag" #-}
annTypesAndErrors _backTree
(tpeToT _tpe )
(getErrors _tpe )
$ Just (map StatementTypeA _statementType ++
[CatUpdates _catUpdates ])
{-# LINE 10590 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 67, column 9)
_lhsOcatUpdates =
{-# LINE 67 "./TypeChecking/Statements.ag" #-}
_catUpdates
{-# LINE 10595 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 68, column 9)
_lhsOlibUpdates =
{-# LINE 68 "./TypeChecking/Statements.ag" #-}
_libUpdates
{-# LINE 10600 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 73, column 9)
_libUpdates =
{-# LINE 73 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 10605 "AstInternal.hs" #-}
-- "./TypeChecking/MiscCreates.ag"(line 75, column 9)
_tpe =
{-# LINE 75 "./TypeChecking/MiscCreates.ag" #-}
Right $ Pseudo Void
{-# LINE 10610 "AstInternal.hs" #-}
-- "./TypeChecking/MiscCreates.ag"(line 76, column 9)
_backTree =
{-# LINE 76 "./TypeChecking/MiscCreates.ag" #-}
CreateLanguage ann_ name_
{-# LINE 10615 "AstInternal.hs" #-}
-- "./TypeChecking/MiscCreates.ag"(line 77, column 9)
_statementType =
{-# LINE 77 "./TypeChecking/MiscCreates.ag" #-}
[]
{-# LINE 10620 "AstInternal.hs" #-}
-- "./TypeChecking/MiscCreates.ag"(line 78, column 9)
_catUpdates =
{-# LINE 78 "./TypeChecking/MiscCreates.ag" #-}
[CatCreateFunction FunName "plpgsql_call_handler" [] (Pseudo LanguageHandler) False
,CatCreateFunction FunName "plpgsql_validator" [ScalarType "oid"] (Pseudo Void) False]
{-# LINE 10626 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
CreateLanguage ann_ name_
{-# LINE 10631 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
CreateLanguage ann_ name_
{-# LINE 10636 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 10641 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree)))
sem_Statement_CreateSequence :: Annotation ->
String ->
Integer ->
Integer ->
Integer ->
Integer ->
Integer ->
T_Statement
sem_Statement_CreateSequence ann_ name_ incr_ min_ max_ start_ cache_ =
(\ _lhsIcat
_lhsIinProducedCat
_lhsIlib ->
(let _lhsOcatUpdates :: ([CatalogUpdate])
_lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_lhsOannotatedTree :: Statement
_lhsOoriginalTree :: Statement
-- "./TypeChecking/Statements.ag"(line 73, column 9)
_libUpdates =
{-# LINE 73 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 10663 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 89, column 9)
_lhsOcatUpdates =
{-# LINE 89 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 10668 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 90, column 9)
_lhsOlibUpdates =
{-# LINE 90 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 10673 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
CreateSequence ann_ name_ incr_ min_ max_ start_ cache_
{-# LINE 10678 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
CreateSequence ann_ name_ incr_ min_ max_ start_ cache_
{-# LINE 10683 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 10688 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 10693 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree)))
sem_Statement_CreateTable :: Annotation ->
String ->
T_AttributeDefList ->
T_ConstraintList ->
T_Statement
sem_Statement_CreateTable ann_ name_ atts_ cons_ =
(\ _lhsIcat
_lhsIinProducedCat
_lhsIlib ->
(let _lhsOannotatedTree :: Statement
_lhsOcatUpdates :: ([CatalogUpdate])
_lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_tpe :: (Either [TypeError] Type)
_catUpdates :: ([CatalogUpdate])
_attrTypes :: ([Type])
_consOlib :: LocalIdentifierBindings
_lhsOoriginalTree :: Statement
_attsOcat :: Catalog
_attsOlib :: LocalIdentifierBindings
_consOcat :: Catalog
_attsIannotatedTree :: AttributeDefList
_attsIattrs :: ([(String, Type)])
_attsIoriginalTree :: AttributeDefList
_consIannotatedTree :: ConstraintList
_consIoriginalTree :: ConstraintList
-- "./TypeChecking/Statements.ag"(line 61, column 9)
_lhsOannotatedTree =
{-# LINE 61 "./TypeChecking/Statements.ag" #-}
annTypesAndErrors _backTree
(tpeToT _tpe )
(getErrors _tpe )
$ Just (map StatementTypeA _statementType ++
[CatUpdates _catUpdates ])
{-# LINE 10728 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 67, column 9)
_lhsOcatUpdates =
{-# LINE 67 "./TypeChecking/Statements.ag" #-}
_catUpdates
{-# LINE 10733 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 68, column 9)
_lhsOlibUpdates =
{-# LINE 68 "./TypeChecking/Statements.ag" #-}
_libUpdates
{-# LINE 10738 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 73, column 9)
_libUpdates =
{-# LINE 73 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 10743 "AstInternal.hs" #-}
-- "./TypeChecking/CreateTable.ag"(line 25, column 9)
_tpe =
{-# LINE 25 "./TypeChecking/CreateTable.ag" #-}
dependsOnRTpe _attrTypes $ Right $ Pseudo Void
{-# LINE 10748 "AstInternal.hs" #-}
-- "./TypeChecking/CreateTable.ag"(line 26, column 9)
_catUpdates =
{-# LINE 26 "./TypeChecking/CreateTable.ag" #-}
dependsOn _attrTypes []
[CatCreateTable name_ _attsIattrs defaultSystemColumns]
{-# LINE 10754 "AstInternal.hs" #-}
-- "./TypeChecking/CreateTable.ag"(line 29, column 9)
_attrTypes =
{-# LINE 29 "./TypeChecking/CreateTable.ag" #-}
map snd _attsIattrs
{-# LINE 10759 "AstInternal.hs" #-}
-- "./TypeChecking/CreateTable.ag"(line 31, column 9)
_statementType =
{-# LINE 31 "./TypeChecking/CreateTable.ag" #-}
[]
{-# LINE 10764 "AstInternal.hs" #-}
-- "./TypeChecking/CreateTable.ag"(line 32, column 9)
_backTree =
{-# LINE 32 "./TypeChecking/CreateTable.ag" #-}
CreateTable ann_
name_
_attsIannotatedTree
_consIannotatedTree
{-# LINE 10772 "AstInternal.hs" #-}
-- "./TypeChecking/CreateTable.ag"(line 36, column 9)
_consOlib =
{-# LINE 36 "./TypeChecking/CreateTable.ag" #-}
case updateBindings _lhsIlib _lhsIcat
[LibStackIDs [("", _attsIattrs)]] of
Left x -> error $ show x
Right e -> e
{-# LINE 10780 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
CreateTable ann_ name_ _attsIannotatedTree _consIannotatedTree
{-# LINE 10785 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
CreateTable ann_ name_ _attsIoriginalTree _consIoriginalTree
{-# LINE 10790 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 10795 "AstInternal.hs" #-}
-- copy rule (down)
_attsOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 10800 "AstInternal.hs" #-}
-- copy rule (down)
_attsOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 10805 "AstInternal.hs" #-}
-- copy rule (down)
_consOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 10810 "AstInternal.hs" #-}
( _attsIannotatedTree,_attsIattrs,_attsIoriginalTree) =
(atts_ _attsOcat _attsOlib )
( _consIannotatedTree,_consIoriginalTree) =
(cons_ _consOcat _consOlib )
in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree)))
sem_Statement_CreateTableAs :: Annotation ->
String ->
T_SelectExpression ->
T_Statement
sem_Statement_CreateTableAs ann_ name_ expr_ =
(\ _lhsIcat
_lhsIinProducedCat
_lhsIlib ->
(let _lhsOannotatedTree :: Statement
_lhsOcatUpdates :: ([CatalogUpdate])
_lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_tpe :: (Either [TypeError] Type)
_catUpdates :: ([CatalogUpdate])
_lhsOoriginalTree :: Statement
_exprOcat :: Catalog
_exprOlib :: LocalIdentifierBindings
_exprIannotatedTree :: SelectExpression
_exprIlibUpdates :: ([LocalIdentifierBindingsUpdate])
_exprIoriginalTree :: SelectExpression
-- "./TypeChecking/Statements.ag"(line 61, column 9)
_lhsOannotatedTree =
{-# LINE 61 "./TypeChecking/Statements.ag" #-}
annTypesAndErrors _backTree
(tpeToT _tpe )
(getErrors _tpe )
$ Just (map StatementTypeA _statementType ++
[CatUpdates _catUpdates ])
{-# LINE 10843 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 67, column 9)
_lhsOcatUpdates =
{-# LINE 67 "./TypeChecking/Statements.ag" #-}
_catUpdates
{-# LINE 10848 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 68, column 9)
_lhsOlibUpdates =
{-# LINE 68 "./TypeChecking/Statements.ag" #-}
_libUpdates
{-# LINE 10853 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 73, column 9)
_libUpdates =
{-# LINE 73 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 10858 "AstInternal.hs" #-}
-- "./TypeChecking/CreateTable.ag"(line 53, column 9)
_tpe =
{-# LINE 53 "./TypeChecking/CreateTable.ag" #-}
dependsOnRTpe [_selType ] $ do
_attrs
Right _selType
{-# LINE 10865 "AstInternal.hs" #-}
-- "./TypeChecking/CreateTable.ag"(line 57, column 9)
_catUpdates =
{-# LINE 57 "./TypeChecking/CreateTable.ag" #-}
leftToEmpty (\as -> [CatCreateTable name_ as defaultSystemColumns]) $ do
ats <- _attrs
return $ dependsOn (tpeToT _tpe :
(map snd ats)) [] ats
{-# LINE 10873 "AstInternal.hs" #-}
-- "./TypeChecking/CreateTable.ag"(line 63, column 9)
_selType =
{-# LINE 63 "./TypeChecking/CreateTable.ag" #-}
getTypeAnnotation _exprIannotatedTree
{-# LINE 10878 "AstInternal.hs" #-}
-- "./TypeChecking/CreateTable.ag"(line 65, column 9)
_attrs =
{-# LINE 65 "./TypeChecking/CreateTable.ag" #-}
unwrapSetOfComposite _selType
{-# LINE 10883 "AstInternal.hs" #-}
-- "./TypeChecking/CreateTable.ag"(line 67, column 9)
_backTree =
{-# LINE 67 "./TypeChecking/CreateTable.ag" #-}
CreateTableAs ann_ name_ _exprIannotatedTree
{-# LINE 10888 "AstInternal.hs" #-}
-- "./TypeChecking/CreateTable.ag"(line 68, column 9)
_statementType =
{-# LINE 68 "./TypeChecking/CreateTable.ag" #-}
[]
{-# LINE 10893 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
CreateTableAs ann_ name_ _exprIannotatedTree
{-# LINE 10898 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
CreateTableAs ann_ name_ _exprIoriginalTree
{-# LINE 10903 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 10908 "AstInternal.hs" #-}
-- copy rule (down)
_exprOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 10913 "AstInternal.hs" #-}
-- copy rule (down)
_exprOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 10918 "AstInternal.hs" #-}
( _exprIannotatedTree,_exprIlibUpdates,_exprIoriginalTree) =
(expr_ _exprOcat _exprOlib )
in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree)))
sem_Statement_CreateTrigger :: Annotation ->
String ->
T_TriggerWhen ->
([TriggerEvent]) ->
String ->
T_TriggerFire ->
String ->
([Expression]) ->
T_Statement
sem_Statement_CreateTrigger ann_ name_ wh_ events_ tbl_ firing_ fnName_ fnArgs_ =
(\ _lhsIcat
_lhsIinProducedCat
_lhsIlib ->
(let _lhsOcatUpdates :: ([CatalogUpdate])
_lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_lhsOannotatedTree :: Statement
_lhsOoriginalTree :: Statement
_whOcat :: Catalog
_whOlib :: LocalIdentifierBindings
_firingOcat :: Catalog
_firingOlib :: LocalIdentifierBindings
_whIannotatedTree :: TriggerWhen
_whIoriginalTree :: TriggerWhen
_firingIannotatedTree :: TriggerFire
_firingIoriginalTree :: TriggerFire
-- "./TypeChecking/Statements.ag"(line 89, column 9)
_lhsOcatUpdates =
{-# LINE 89 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 10951 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 90, column 9)
_lhsOlibUpdates =
{-# LINE 90 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 10956 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
CreateTrigger ann_ name_ _whIannotatedTree events_ tbl_ _firingIannotatedTree fnName_ fnArgs_
{-# LINE 10961 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
CreateTrigger ann_ name_ _whIoriginalTree events_ tbl_ _firingIoriginalTree fnName_ fnArgs_
{-# LINE 10966 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 10971 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 10976 "AstInternal.hs" #-}
-- copy rule (down)
_whOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 10981 "AstInternal.hs" #-}
-- copy rule (down)
_whOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 10986 "AstInternal.hs" #-}
-- copy rule (down)
_firingOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 10991 "AstInternal.hs" #-}
-- copy rule (down)
_firingOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 10996 "AstInternal.hs" #-}
( _whIannotatedTree,_whIoriginalTree) =
(wh_ _whOcat _whOlib )
( _firingIannotatedTree,_firingIoriginalTree) =
(firing_ _firingOcat _firingOlib )
in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree)))
sem_Statement_CreateType :: Annotation ->
String ->
T_TypeAttributeDefList ->
T_Statement
sem_Statement_CreateType ann_ name_ atts_ =
(\ _lhsIcat
_lhsIinProducedCat
_lhsIlib ->
(let _lhsOannotatedTree :: Statement
_lhsOcatUpdates :: ([CatalogUpdate])
_lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_tpe :: (Either [TypeError] Type)
_catUpdates :: ([CatalogUpdate])
_lhsOoriginalTree :: Statement
_attsOcat :: Catalog
_attsOlib :: LocalIdentifierBindings
_attsIannotatedTree :: TypeAttributeDefList
_attsIattrs :: ([(String, Type)])
_attsIoriginalTree :: TypeAttributeDefList
-- "./TypeChecking/Statements.ag"(line 61, column 9)
_lhsOannotatedTree =
{-# LINE 61 "./TypeChecking/Statements.ag" #-}
annTypesAndErrors _backTree
(tpeToT _tpe )
(getErrors _tpe )
$ Just (map StatementTypeA _statementType ++
[CatUpdates _catUpdates ])
{-# LINE 11029 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 67, column 9)
_lhsOcatUpdates =
{-# LINE 67 "./TypeChecking/Statements.ag" #-}
_catUpdates
{-# LINE 11034 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 68, column 9)
_lhsOlibUpdates =
{-# LINE 68 "./TypeChecking/Statements.ag" #-}
_libUpdates
{-# LINE 11039 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 73, column 9)
_libUpdates =
{-# LINE 73 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 11044 "AstInternal.hs" #-}
-- "./TypeChecking/MiscCreates.ag"(line 51, column 9)
_tpe =
{-# LINE 51 "./TypeChecking/MiscCreates.ag" #-}
Right $ Pseudo Void
{-# LINE 11049 "AstInternal.hs" #-}
-- "./TypeChecking/MiscCreates.ag"(line 52, column 9)
_backTree =
{-# LINE 52 "./TypeChecking/MiscCreates.ag" #-}
CreateType ann_ name_ _attsIannotatedTree
{-# LINE 11054 "AstInternal.hs" #-}
-- "./TypeChecking/MiscCreates.ag"(line 53, column 9)
_statementType =
{-# LINE 53 "./TypeChecking/MiscCreates.ag" #-}
[]
{-# LINE 11059 "AstInternal.hs" #-}
-- "./TypeChecking/MiscCreates.ag"(line 54, column 9)
_catUpdates =
{-# LINE 54 "./TypeChecking/MiscCreates.ag" #-}
[CatCreateComposite name_ _attsIattrs]
{-# LINE 11064 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
CreateType ann_ name_ _attsIannotatedTree
{-# LINE 11069 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
CreateType ann_ name_ _attsIoriginalTree
{-# LINE 11074 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 11079 "AstInternal.hs" #-}
-- copy rule (down)
_attsOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 11084 "AstInternal.hs" #-}
-- copy rule (down)
_attsOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 11089 "AstInternal.hs" #-}
( _attsIannotatedTree,_attsIattrs,_attsIoriginalTree) =
(atts_ _attsOcat _attsOlib )
in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree)))
sem_Statement_CreateView :: Annotation ->
String ->
T_SelectExpression ->
T_Statement
sem_Statement_CreateView ann_ name_ expr_ =
(\ _lhsIcat
_lhsIinProducedCat
_lhsIlib ->
(let _lhsOannotatedTree :: Statement
_lhsOcatUpdates :: ([CatalogUpdate])
_lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_tpe :: (Either [TypeError] Type)
_catUpdates :: ([CatalogUpdate])
_lhsOoriginalTree :: Statement
_exprOcat :: Catalog
_exprOlib :: LocalIdentifierBindings
_exprIannotatedTree :: SelectExpression
_exprIlibUpdates :: ([LocalIdentifierBindingsUpdate])
_exprIoriginalTree :: SelectExpression
-- "./TypeChecking/Statements.ag"(line 61, column 9)
_lhsOannotatedTree =
{-# LINE 61 "./TypeChecking/Statements.ag" #-}
annTypesAndErrors _backTree
(tpeToT _tpe )
(getErrors _tpe )
$ Just (map StatementTypeA _statementType ++
[CatUpdates _catUpdates ])
{-# LINE 11120 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 67, column 9)
_lhsOcatUpdates =
{-# LINE 67 "./TypeChecking/Statements.ag" #-}
_catUpdates
{-# LINE 11125 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 68, column 9)
_lhsOlibUpdates =
{-# LINE 68 "./TypeChecking/Statements.ag" #-}
_libUpdates
{-# LINE 11130 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 73, column 9)
_libUpdates =
{-# LINE 73 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 11135 "AstInternal.hs" #-}
-- "./TypeChecking/MiscCreates.ag"(line 15, column 9)
_tpe =
{-# LINE 15 "./TypeChecking/MiscCreates.ag" #-}
dependsOnRTpe [getTypeAnnotation _exprIannotatedTree] $
Right $ Pseudo Void
{-# LINE 11141 "AstInternal.hs" #-}
-- "./TypeChecking/MiscCreates.ag"(line 17, column 9)
_backTree =
{-# LINE 17 "./TypeChecking/MiscCreates.ag" #-}
CreateView ann_ name_ _exprIannotatedTree
{-# LINE 11146 "AstInternal.hs" #-}
-- "./TypeChecking/MiscCreates.ag"(line 18, column 9)
_attrs =
{-# LINE 18 "./TypeChecking/MiscCreates.ag" #-}
case getTypeAnnotation _exprIannotatedTree of
SetOfType (CompositeType c) -> c
_ -> []
{-# LINE 11153 "AstInternal.hs" #-}
-- "./TypeChecking/MiscCreates.ag"(line 21, column 9)
_catUpdates =
{-# LINE 21 "./TypeChecking/MiscCreates.ag" #-}
[CatCreateView name_ _attrs ]
{-# LINE 11158 "AstInternal.hs" #-}
-- "./TypeChecking/MiscCreates.ag"(line 22, column 9)
_statementType =
{-# LINE 22 "./TypeChecking/MiscCreates.ag" #-}
[]
{-# LINE 11163 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
CreateView ann_ name_ _exprIannotatedTree
{-# LINE 11168 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
CreateView ann_ name_ _exprIoriginalTree
{-# LINE 11173 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 11178 "AstInternal.hs" #-}
-- copy rule (down)
_exprOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 11183 "AstInternal.hs" #-}
-- copy rule (down)
_exprOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 11188 "AstInternal.hs" #-}
( _exprIannotatedTree,_exprIlibUpdates,_exprIoriginalTree) =
(expr_ _exprOcat _exprOlib )
in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree)))
sem_Statement_Delete :: Annotation ->
String ->
T_MaybeBoolExpression ->
T_MaybeSelectList ->
T_Statement
sem_Statement_Delete ann_ table_ whr_ returning_ =
(\ _lhsIcat
_lhsIinProducedCat
_lhsIlib ->
(let _lhsOannotatedTree :: Statement
_lhsOcatUpdates :: ([CatalogUpdate])
_lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_tpe :: (Either [TypeError] Type)
_catUpdates :: ([CatalogUpdate])
_whrOlib :: LocalIdentifierBindings
_returningOlib :: LocalIdentifierBindings
_lhsOoriginalTree :: Statement
_whrOcat :: Catalog
_returningOcat :: Catalog
_whrIannotatedTree :: MaybeBoolExpression
_whrIoriginalTree :: MaybeBoolExpression
_returningIannotatedTree :: MaybeSelectList
_returningIlistType :: (Maybe [(String,Type)])
_returningIoriginalTree :: MaybeSelectList
-- "./TypeChecking/Statements.ag"(line 61, column 9)
_lhsOannotatedTree =
{-# LINE 61 "./TypeChecking/Statements.ag" #-}
annTypesAndErrors _backTree
(tpeToT _tpe )
(getErrors _tpe )
$ Just (map StatementTypeA _statementType ++
[CatUpdates _catUpdates ])
{-# LINE 11224 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 67, column 9)
_lhsOcatUpdates =
{-# LINE 67 "./TypeChecking/Statements.ag" #-}
_catUpdates
{-# LINE 11229 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 68, column 9)
_lhsOlibUpdates =
{-# LINE 68 "./TypeChecking/Statements.ag" #-}
_libUpdates
{-# LINE 11234 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 73, column 9)
_libUpdates =
{-# LINE 73 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 11239 "AstInternal.hs" #-}
-- "./TypeChecking/Dml.ag"(line 180, column 9)
_tpe =
{-# LINE 180 "./TypeChecking/Dml.ag" #-}
checkRelationExists _lhsIcat table_ >>
Right (Pseudo Void)
{-# LINE 11245 "AstInternal.hs" #-}
-- "./TypeChecking/Dml.ag"(line 183, column 9)
_statementType =
{-# LINE 183 "./TypeChecking/Dml.ag" #-}
[StatementType (getPlaceholderTypes _whrIannotatedTree)
(fromMaybe [] _returningIlistType)]
{-# LINE 11251 "AstInternal.hs" #-}
-- "./TypeChecking/Dml.ag"(line 186, column 9)
_backTree =
{-# LINE 186 "./TypeChecking/Dml.ag" #-}
Delete ann_ table_ _whrIannotatedTree _returningIannotatedTree
{-# LINE 11256 "AstInternal.hs" #-}
-- "./TypeChecking/Dml.ag"(line 187, column 9)
_catUpdates =
{-# LINE 187 "./TypeChecking/Dml.ag" #-}
[]
{-# LINE 11261 "AstInternal.hs" #-}
-- "./TypeChecking/Dml.ag"(line 192, column 9)
_lib =
{-# LINE 192 "./TypeChecking/Dml.ag" #-}
fromRight _lhsIlib $ do
columnTypes <- catCompositeAttrs _lhsIcat relationComposites table_
updateBindings _lhsIlib _lhsIcat [LibStackIDs [("", columnTypes)]]
{-# LINE 11268 "AstInternal.hs" #-}
-- "./TypeChecking/Dml.ag"(line 196, column 9)
_whrOlib =
{-# LINE 196 "./TypeChecking/Dml.ag" #-}
_lib
{-# LINE 11273 "AstInternal.hs" #-}
-- "./TypeChecking/Dml.ag"(line 197, column 9)
_returningOlib =
{-# LINE 197 "./TypeChecking/Dml.ag" #-}
_lib
{-# LINE 11278 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
Delete ann_ table_ _whrIannotatedTree _returningIannotatedTree
{-# LINE 11283 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
Delete ann_ table_ _whrIoriginalTree _returningIoriginalTree
{-# LINE 11288 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 11293 "AstInternal.hs" #-}
-- copy rule (down)
_whrOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 11298 "AstInternal.hs" #-}
-- copy rule (down)
_returningOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 11303 "AstInternal.hs" #-}
( _whrIannotatedTree,_whrIoriginalTree) =
(whr_ _whrOcat _whrOlib )
( _returningIannotatedTree,_returningIlistType,_returningIoriginalTree) =
(returning_ _returningOcat _returningOlib )
in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree)))
sem_Statement_DropFunction :: Annotation ->
T_IfExists ->
T_StringTypeNameListPairList ->
T_Cascade ->
T_Statement
sem_Statement_DropFunction ann_ ifE_ sigs_ cascade_ =
(\ _lhsIcat
_lhsIinProducedCat
_lhsIlib ->
(let _lhsOannotatedTree :: Statement
_lhsOcatUpdates :: ([CatalogUpdate])
_lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_tpe :: (Either [TypeError] Type)
_catUpdates :: ([CatalogUpdate])
_lhsOoriginalTree :: Statement
_ifEOcat :: Catalog
_ifEOlib :: LocalIdentifierBindings
_sigsOcat :: Catalog
_sigsOlib :: LocalIdentifierBindings
_cascadeOcat :: Catalog
_cascadeOlib :: LocalIdentifierBindings
_ifEIannotatedTree :: IfExists
_ifEIoriginalTree :: IfExists
_sigsIannotatedTree :: StringTypeNameListPairList
_sigsIfnSigs :: ([(String,[Type])])
_sigsIoriginalTree :: StringTypeNameListPairList
_cascadeIannotatedTree :: Cascade
_cascadeIoriginalTree :: Cascade
-- "./TypeChecking/Statements.ag"(line 61, column 9)
_lhsOannotatedTree =
{-# LINE 61 "./TypeChecking/Statements.ag" #-}
annTypesAndErrors _backTree
(tpeToT _tpe )
(getErrors _tpe )
$ Just (map StatementTypeA _statementType ++
[CatUpdates _catUpdates ])
{-# LINE 11345 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 67, column 9)
_lhsOcatUpdates =
{-# LINE 67 "./TypeChecking/Statements.ag" #-}
_catUpdates
{-# LINE 11350 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 68, column 9)
_lhsOlibUpdates =
{-# LINE 68 "./TypeChecking/Statements.ag" #-}
_libUpdates
{-# LINE 11355 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 73, column 9)
_libUpdates =
{-# LINE 73 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 11360 "AstInternal.hs" #-}
-- "./TypeChecking/Drops.ag"(line 10, column 9)
_tpe =
{-# LINE 10 "./TypeChecking/Drops.ag" #-}
Right $ Pseudo Void
{-# LINE 11365 "AstInternal.hs" #-}
-- "./TypeChecking/Drops.ag"(line 11, column 9)
_backTree =
{-# LINE 11 "./TypeChecking/Drops.ag" #-}
DropFunction ann_ _ifEIannotatedTree _sigsIannotatedTree _cascadeIannotatedTree
{-# LINE 11370 "AstInternal.hs" #-}
-- "./TypeChecking/Drops.ag"(line 12, column 9)
_catUpdates =
{-# LINE 12 "./TypeChecking/Drops.ag" #-}
flip map _sigsIfnSigs $ \(nm,args) ->
CatDropFunction ifE nm args
where
ifE = _ifEIannotatedTree == IfExists
{-# LINE 11378 "AstInternal.hs" #-}
-- "./TypeChecking/Drops.ag"(line 16, column 9)
_statementType =
{-# LINE 16 "./TypeChecking/Drops.ag" #-}
[]
{-# LINE 11383 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
DropFunction ann_ _ifEIannotatedTree _sigsIannotatedTree _cascadeIannotatedTree
{-# LINE 11388 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
DropFunction ann_ _ifEIoriginalTree _sigsIoriginalTree _cascadeIoriginalTree
{-# LINE 11393 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 11398 "AstInternal.hs" #-}
-- copy rule (down)
_ifEOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 11403 "AstInternal.hs" #-}
-- copy rule (down)
_ifEOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 11408 "AstInternal.hs" #-}
-- copy rule (down)
_sigsOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 11413 "AstInternal.hs" #-}
-- copy rule (down)
_sigsOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 11418 "AstInternal.hs" #-}
-- copy rule (down)
_cascadeOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 11423 "AstInternal.hs" #-}
-- copy rule (down)
_cascadeOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 11428 "AstInternal.hs" #-}
( _ifEIannotatedTree,_ifEIoriginalTree) =
(ifE_ _ifEOcat _ifEOlib )
( _sigsIannotatedTree,_sigsIfnSigs,_sigsIoriginalTree) =
(sigs_ _sigsOcat _sigsOlib )
( _cascadeIannotatedTree,_cascadeIoriginalTree) =
(cascade_ _cascadeOcat _cascadeOlib )
in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree)))
sem_Statement_DropSomething :: Annotation ->
T_DropType ->
T_IfExists ->
T_StringList ->
T_Cascade ->
T_Statement
sem_Statement_DropSomething ann_ dropType_ ifE_ names_ cascade_ =
(\ _lhsIcat
_lhsIinProducedCat
_lhsIlib ->
(let _lhsOcatUpdates :: ([CatalogUpdate])
_lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_lhsOannotatedTree :: Statement
_lhsOoriginalTree :: Statement
_dropTypeOcat :: Catalog
_dropTypeOlib :: LocalIdentifierBindings
_ifEOcat :: Catalog
_ifEOlib :: LocalIdentifierBindings
_namesOcat :: Catalog
_namesOlib :: LocalIdentifierBindings
_cascadeOcat :: Catalog
_cascadeOlib :: LocalIdentifierBindings
_dropTypeIannotatedTree :: DropType
_dropTypeIoriginalTree :: DropType
_ifEIannotatedTree :: IfExists
_ifEIoriginalTree :: IfExists
_namesIannotatedTree :: StringList
_namesIoriginalTree :: StringList
_namesIstrings :: ([String])
_cascadeIannotatedTree :: Cascade
_cascadeIoriginalTree :: Cascade
-- "./TypeChecking/Statements.ag"(line 89, column 9)
_lhsOcatUpdates =
{-# LINE 89 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 11471 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 90, column 9)
_lhsOlibUpdates =
{-# LINE 90 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 11476 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
DropSomething ann_ _dropTypeIannotatedTree _ifEIannotatedTree _namesIannotatedTree _cascadeIannotatedTree
{-# LINE 11481 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
DropSomething ann_ _dropTypeIoriginalTree _ifEIoriginalTree _namesIoriginalTree _cascadeIoriginalTree
{-# LINE 11486 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 11491 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 11496 "AstInternal.hs" #-}
-- copy rule (down)
_dropTypeOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 11501 "AstInternal.hs" #-}
-- copy rule (down)
_dropTypeOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 11506 "AstInternal.hs" #-}
-- copy rule (down)
_ifEOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 11511 "AstInternal.hs" #-}
-- copy rule (down)
_ifEOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 11516 "AstInternal.hs" #-}
-- copy rule (down)
_namesOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 11521 "AstInternal.hs" #-}
-- copy rule (down)
_namesOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 11526 "AstInternal.hs" #-}
-- copy rule (down)
_cascadeOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 11531 "AstInternal.hs" #-}
-- copy rule (down)
_cascadeOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 11536 "AstInternal.hs" #-}
( _dropTypeIannotatedTree,_dropTypeIoriginalTree) =
(dropType_ _dropTypeOcat _dropTypeOlib )
( _ifEIannotatedTree,_ifEIoriginalTree) =
(ifE_ _ifEOcat _ifEOlib )
( _namesIannotatedTree,_namesIoriginalTree,_namesIstrings) =
(names_ _namesOcat _namesOlib )
( _cascadeIannotatedTree,_cascadeIoriginalTree) =
(cascade_ _cascadeOcat _cascadeOlib )
in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree)))
sem_Statement_Execute :: Annotation ->
T_Expression ->
T_Statement
sem_Statement_Execute ann_ expr_ =
(\ _lhsIcat
_lhsIinProducedCat
_lhsIlib ->
(let _lhsOcatUpdates :: ([CatalogUpdate])
_lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_lhsOannotatedTree :: Statement
_lhsOoriginalTree :: Statement
_exprOcat :: Catalog
_exprOlib :: LocalIdentifierBindings
_exprIannotatedTree :: Expression
_exprIliftedColumnName :: String
_exprIoriginalTree :: Expression
-- "./TypeChecking/Statements.ag"(line 89, column 9)
_lhsOcatUpdates =
{-# LINE 89 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 11566 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 90, column 9)
_lhsOlibUpdates =
{-# LINE 90 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 11571 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
Execute ann_ _exprIannotatedTree
{-# LINE 11576 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
Execute ann_ _exprIoriginalTree
{-# LINE 11581 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 11586 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 11591 "AstInternal.hs" #-}
-- copy rule (down)
_exprOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 11596 "AstInternal.hs" #-}
-- copy rule (down)
_exprOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 11601 "AstInternal.hs" #-}
( _exprIannotatedTree,_exprIliftedColumnName,_exprIoriginalTree) =
(expr_ _exprOcat _exprOlib )
in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree)))
sem_Statement_ExecuteInto :: Annotation ->
T_Expression ->
T_StringList ->
T_Statement
sem_Statement_ExecuteInto ann_ expr_ targets_ =
(\ _lhsIcat
_lhsIinProducedCat
_lhsIlib ->
(let _lhsOcatUpdates :: ([CatalogUpdate])
_lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_lhsOannotatedTree :: Statement
_lhsOoriginalTree :: Statement
_exprOcat :: Catalog
_exprOlib :: LocalIdentifierBindings
_targetsOcat :: Catalog
_targetsOlib :: LocalIdentifierBindings
_exprIannotatedTree :: Expression
_exprIliftedColumnName :: String
_exprIoriginalTree :: Expression
_targetsIannotatedTree :: StringList
_targetsIoriginalTree :: StringList
_targetsIstrings :: ([String])
-- "./TypeChecking/Statements.ag"(line 89, column 9)
_lhsOcatUpdates =
{-# LINE 89 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 11631 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 90, column 9)
_lhsOlibUpdates =
{-# LINE 90 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 11636 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
ExecuteInto ann_ _exprIannotatedTree _targetsIannotatedTree
{-# LINE 11641 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
ExecuteInto ann_ _exprIoriginalTree _targetsIoriginalTree
{-# LINE 11646 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 11651 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 11656 "AstInternal.hs" #-}
-- copy rule (down)
_exprOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 11661 "AstInternal.hs" #-}
-- copy rule (down)
_exprOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 11666 "AstInternal.hs" #-}
-- copy rule (down)
_targetsOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 11671 "AstInternal.hs" #-}
-- copy rule (down)
_targetsOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 11676 "AstInternal.hs" #-}
( _exprIannotatedTree,_exprIliftedColumnName,_exprIoriginalTree) =
(expr_ _exprOcat _exprOlib )
( _targetsIannotatedTree,_targetsIoriginalTree,_targetsIstrings) =
(targets_ _targetsOcat _targetsOlib )
in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree)))
sem_Statement_ForIntegerStatement :: Annotation ->
String ->
T_Expression ->
T_Expression ->
T_StatementList ->
T_Statement
sem_Statement_ForIntegerStatement ann_ var_ from_ to_ sts_ =
(\ _lhsIcat
_lhsIinProducedCat
_lhsIlib ->
(let _lhsOannotatedTree :: Statement
_lhsOcatUpdates :: ([CatalogUpdate])
_lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_stsOcatUpdates :: ([CatalogUpdate])
_stsOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_tpe :: (Either [TypeError] Type)
_stsOlib :: LocalIdentifierBindings
_catUpdates :: ([CatalogUpdate])
_lhsOoriginalTree :: Statement
_fromOcat :: Catalog
_fromOlib :: LocalIdentifierBindings
_toOcat :: Catalog
_toOlib :: LocalIdentifierBindings
_stsOcat :: Catalog
_fromIannotatedTree :: Expression
_fromIliftedColumnName :: String
_fromIoriginalTree :: Expression
_toIannotatedTree :: Expression
_toIliftedColumnName :: String
_toIoriginalTree :: Expression
_stsIannotatedTree :: StatementList
_stsIoriginalTree :: StatementList
_stsIproducedCat :: Catalog
_stsIproducedLib :: LocalIdentifierBindings
-- "./TypeChecking/Statements.ag"(line 61, column 9)
_lhsOannotatedTree =
{-# LINE 61 "./TypeChecking/Statements.ag" #-}
annTypesAndErrors _backTree
(tpeToT _tpe )
(getErrors _tpe )
$ Just (map StatementTypeA _statementType ++
[CatUpdates _catUpdates ])
{-# LINE 11724 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 67, column 9)
_lhsOcatUpdates =
{-# LINE 67 "./TypeChecking/Statements.ag" #-}
_catUpdates
{-# LINE 11729 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 68, column 9)
_lhsOlibUpdates =
{-# LINE 68 "./TypeChecking/Statements.ag" #-}
_libUpdates
{-# LINE 11734 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 73, column 9)
_libUpdates =
{-# LINE 73 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 11739 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 110, column 9)
_stsOcatUpdates =
{-# LINE 110 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 11744 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 111, column 9)
_stsOlibUpdates =
{-# LINE 111 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 11749 "AstInternal.hs" #-}
-- "./TypeChecking/Plpgsql.ag"(line 36, column 9)
_varTypeE =
{-# LINE 36 "./TypeChecking/Plpgsql.ag" #-}
libLookupID _lhsIlib var_
{-# LINE 11754 "AstInternal.hs" #-}
-- "./TypeChecking/Plpgsql.ag"(line 37, column 9)
_tpe =
{-# LINE 37 "./TypeChecking/Plpgsql.ag" #-}
do
let fromType = getTypeAnnotation _fromIannotatedTree
toType = getTypeAnnotation _toIannotatedTree
dependsOnRTpe [fromType,toType] $ do
errorWhen (fromType /= toType) [FromToTypesNotSame fromType toType]
case _varTypeE of
Right t -> checkAssignmentValid _lhsIcat fromType t
Left _ -> return ()
return $ Pseudo Void
{-# LINE 11767 "AstInternal.hs" #-}
-- "./TypeChecking/Plpgsql.ag"(line 48, column 9)
_stsOlib =
{-# LINE 48 "./TypeChecking/Plpgsql.ag" #-}
case _varTypeE of
Left [UnrecognisedIdentifier var_] ->
fromRight _lhsIlib $
updateBindings _lhsIlib _lhsIcat
[LibStackIDs [("", [(var_,getTypeAnnotation _fromIannotatedTree)])]]
_ -> _lhsIlib
{-# LINE 11777 "AstInternal.hs" #-}
-- "./TypeChecking/Plpgsql.ag"(line 56, column 9)
_backTree =
{-# LINE 56 "./TypeChecking/Plpgsql.ag" #-}
ForIntegerStatement ann_ var_ _fromIannotatedTree _toIannotatedTree _stsIannotatedTree
{-# LINE 11782 "AstInternal.hs" #-}
-- "./TypeChecking/Plpgsql.ag"(line 57, column 9)
_catUpdates =
{-# LINE 57 "./TypeChecking/Plpgsql.ag" #-}
[]
{-# LINE 11787 "AstInternal.hs" #-}
-- "./TypeChecking/Plpgsql.ag"(line 58, column 9)
_statementType =
{-# LINE 58 "./TypeChecking/Plpgsql.ag" #-}
[]
{-# LINE 11792 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
ForIntegerStatement ann_ var_ _fromIannotatedTree _toIannotatedTree _stsIannotatedTree
{-# LINE 11797 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
ForIntegerStatement ann_ var_ _fromIoriginalTree _toIoriginalTree _stsIoriginalTree
{-# LINE 11802 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 11807 "AstInternal.hs" #-}
-- copy rule (down)
_fromOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 11812 "AstInternal.hs" #-}
-- copy rule (down)
_fromOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 11817 "AstInternal.hs" #-}
-- copy rule (down)
_toOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 11822 "AstInternal.hs" #-}
-- copy rule (down)
_toOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 11827 "AstInternal.hs" #-}
-- copy rule (down)
_stsOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 11832 "AstInternal.hs" #-}
( _fromIannotatedTree,_fromIliftedColumnName,_fromIoriginalTree) =
(from_ _fromOcat _fromOlib )
( _toIannotatedTree,_toIliftedColumnName,_toIoriginalTree) =
(to_ _toOcat _toOlib )
( _stsIannotatedTree,_stsIoriginalTree,_stsIproducedCat,_stsIproducedLib) =
(sts_ _stsOcat _stsOcatUpdates _stsOlib _stsOlibUpdates )
in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree)))
sem_Statement_ForSelectStatement :: Annotation ->
String ->
T_SelectExpression ->
T_StatementList ->
T_Statement
sem_Statement_ForSelectStatement ann_ var_ sel_ sts_ =
(\ _lhsIcat
_lhsIinProducedCat
_lhsIlib ->
(let _lhsOannotatedTree :: Statement
_lhsOcatUpdates :: ([CatalogUpdate])
_lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_stsOcatUpdates :: ([CatalogUpdate])
_stsOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_tpe :: (Either [TypeError] Type)
_stsOlib :: LocalIdentifierBindings
_catUpdates :: ([CatalogUpdate])
_lhsOoriginalTree :: Statement
_selOcat :: Catalog
_selOlib :: LocalIdentifierBindings
_stsOcat :: Catalog
_selIannotatedTree :: SelectExpression
_selIlibUpdates :: ([LocalIdentifierBindingsUpdate])
_selIoriginalTree :: SelectExpression
_stsIannotatedTree :: StatementList
_stsIoriginalTree :: StatementList
_stsIproducedCat :: Catalog
_stsIproducedLib :: LocalIdentifierBindings
-- "./TypeChecking/Statements.ag"(line 61, column 9)
_lhsOannotatedTree =
{-# LINE 61 "./TypeChecking/Statements.ag" #-}
annTypesAndErrors _backTree
(tpeToT _tpe )
(getErrors _tpe )
$ Just (map StatementTypeA _statementType ++
[CatUpdates _catUpdates ])
{-# LINE 11876 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 67, column 9)
_lhsOcatUpdates =
{-# LINE 67 "./TypeChecking/Statements.ag" #-}
_catUpdates
{-# LINE 11881 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 68, column 9)
_lhsOlibUpdates =
{-# LINE 68 "./TypeChecking/Statements.ag" #-}
_libUpdates
{-# LINE 11886 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 73, column 9)
_libUpdates =
{-# LINE 73 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 11891 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 110, column 9)
_stsOcatUpdates =
{-# LINE 110 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 11896 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 111, column 9)
_stsOlibUpdates =
{-# LINE 111 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 11901 "AstInternal.hs" #-}
-- "./TypeChecking/Plpgsql.ag"(line 63, column 9)
_selType =
{-# LINE 63 "./TypeChecking/Plpgsql.ag" #-}
getTypeAnnotation _selIannotatedTree
{-# LINE 11906 "AstInternal.hs" #-}
-- "./TypeChecking/Plpgsql.ag"(line 64, column 9)
_tpe =
{-# LINE 64 "./TypeChecking/Plpgsql.ag" #-}
do
dependsOnRTpe [_selType ] $ do
toType <- libLookupID _lhsIlib var_
dependsOnRTpe [toType] $ do
checkAssignmentValid _lhsIcat _selType toType
return $ Pseudo Void
{-# LINE 11916 "AstInternal.hs" #-}
-- "./TypeChecking/Plpgsql.ag"(line 75, column 9)
_stsOlib =
{-# LINE 75 "./TypeChecking/Plpgsql.ag" #-}
if okToUpdate
then fromRight _lhsIlib $
updateBindings _lhsIlib _lhsIcat [LibStackIDs [("", [(var_,_selType )])]]
else _lhsIlib
where
okToUpdate = isRight _tpe && _selType /= TypeCheckFailed
{-# LINE 11926 "AstInternal.hs" #-}
-- "./TypeChecking/Plpgsql.ag"(line 84, column 9)
_backTree =
{-# LINE 84 "./TypeChecking/Plpgsql.ag" #-}
ForSelectStatement ann_ var_ _selIannotatedTree _stsIannotatedTree
{-# LINE 11931 "AstInternal.hs" #-}
-- "./TypeChecking/Plpgsql.ag"(line 85, column 9)
_catUpdates =
{-# LINE 85 "./TypeChecking/Plpgsql.ag" #-}
[]
{-# LINE 11936 "AstInternal.hs" #-}
-- "./TypeChecking/Plpgsql.ag"(line 86, column 9)
_statementType =
{-# LINE 86 "./TypeChecking/Plpgsql.ag" #-}
[]
{-# LINE 11941 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
ForSelectStatement ann_ var_ _selIannotatedTree _stsIannotatedTree
{-# LINE 11946 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
ForSelectStatement ann_ var_ _selIoriginalTree _stsIoriginalTree
{-# LINE 11951 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 11956 "AstInternal.hs" #-}
-- copy rule (down)
_selOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 11961 "AstInternal.hs" #-}
-- copy rule (down)
_selOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 11966 "AstInternal.hs" #-}
-- copy rule (down)
_stsOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 11971 "AstInternal.hs" #-}
( _selIannotatedTree,_selIlibUpdates,_selIoriginalTree) =
(sel_ _selOcat _selOlib )
( _stsIannotatedTree,_stsIoriginalTree,_stsIproducedCat,_stsIproducedLib) =
(sts_ _stsOcat _stsOcatUpdates _stsOlib _stsOlibUpdates )
in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree)))
sem_Statement_If :: Annotation ->
T_ExpressionStatementListPairList ->
T_StatementList ->
T_Statement
sem_Statement_If ann_ cases_ els_ =
(\ _lhsIcat
_lhsIinProducedCat
_lhsIlib ->
(let _lhsOcatUpdates :: ([CatalogUpdate])
_lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_elsOcatUpdates :: ([CatalogUpdate])
_elsOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_lhsOannotatedTree :: Statement
_lhsOoriginalTree :: Statement
_casesOcat :: Catalog
_casesOlib :: LocalIdentifierBindings
_elsOcat :: Catalog
_elsOlib :: LocalIdentifierBindings
_casesIannotatedTree :: ExpressionStatementListPairList
_casesIoriginalTree :: ExpressionStatementListPairList
_elsIannotatedTree :: StatementList
_elsIoriginalTree :: StatementList
_elsIproducedCat :: Catalog
_elsIproducedLib :: LocalIdentifierBindings
-- "./TypeChecking/Statements.ag"(line 89, column 9)
_lhsOcatUpdates =
{-# LINE 89 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 12005 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 90, column 9)
_lhsOlibUpdates =
{-# LINE 90 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 12010 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 106, column 9)
_elsOcatUpdates =
{-# LINE 106 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 12015 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 107, column 9)
_elsOlibUpdates =
{-# LINE 107 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 12020 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
If ann_ _casesIannotatedTree _elsIannotatedTree
{-# LINE 12025 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
If ann_ _casesIoriginalTree _elsIoriginalTree
{-# LINE 12030 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 12035 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 12040 "AstInternal.hs" #-}
-- copy rule (down)
_casesOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 12045 "AstInternal.hs" #-}
-- copy rule (down)
_casesOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 12050 "AstInternal.hs" #-}
-- copy rule (down)
_elsOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 12055 "AstInternal.hs" #-}
-- copy rule (down)
_elsOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 12060 "AstInternal.hs" #-}
( _casesIannotatedTree,_casesIoriginalTree) =
(cases_ _casesOcat _casesOlib )
( _elsIannotatedTree,_elsIoriginalTree,_elsIproducedCat,_elsIproducedLib) =
(els_ _elsOcat _elsOcatUpdates _elsOlib _elsOlibUpdates )
in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree)))
sem_Statement_Insert :: Annotation ->
String ->
T_StringList ->
T_SelectExpression ->
T_MaybeSelectList ->
T_Statement
sem_Statement_Insert ann_ table_ targetCols_ insData_ returning_ =
(\ _lhsIcat
_lhsIinProducedCat
_lhsIlib ->
(let _lhsOannotatedTree :: Statement
_lhsOcatUpdates :: ([CatalogUpdate])
_lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_tpe :: (Either [TypeError] Type)
_catUpdates :: ([CatalogUpdate])
_returningOlib :: LocalIdentifierBindings
_lhsOoriginalTree :: Statement
_targetColsOcat :: Catalog
_targetColsOlib :: LocalIdentifierBindings
_insDataOcat :: Catalog
_insDataOlib :: LocalIdentifierBindings
_returningOcat :: Catalog
_targetColsIannotatedTree :: StringList
_targetColsIoriginalTree :: StringList
_targetColsIstrings :: ([String])
_insDataIannotatedTree :: SelectExpression
_insDataIlibUpdates :: ([LocalIdentifierBindingsUpdate])
_insDataIoriginalTree :: SelectExpression
_returningIannotatedTree :: MaybeSelectList
_returningIlistType :: (Maybe [(String,Type)])
_returningIoriginalTree :: MaybeSelectList
-- "./TypeChecking/Statements.ag"(line 61, column 9)
_lhsOannotatedTree =
{-# LINE 61 "./TypeChecking/Statements.ag" #-}
annTypesAndErrors _backTree
(tpeToT _tpe )
(getErrors _tpe )
$ Just (map StatementTypeA _statementType ++
[CatUpdates _catUpdates ])
{-# LINE 12105 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 67, column 9)
_lhsOcatUpdates =
{-# LINE 67 "./TypeChecking/Statements.ag" #-}
_catUpdates
{-# LINE 12110 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 68, column 9)
_lhsOlibUpdates =
{-# LINE 68 "./TypeChecking/Statements.ag" #-}
_libUpdates
{-# LINE 12115 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 73, column 9)
_libUpdates =
{-# LINE 73 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 12120 "AstInternal.hs" #-}
-- "./TypeChecking/Dml.ag"(line 18, column 9)
_tpe =
{-# LINE 18 "./TypeChecking/Dml.ag" #-}
dependsOnRTpe [getTypeAnnotation _insDataIannotatedTree] $ do
_columnTypes
Right $ Pseudo Void
{-# LINE 12127 "AstInternal.hs" #-}
-- "./TypeChecking/Dml.ag"(line 22, column 9)
_statementType =
{-# LINE 22 "./TypeChecking/Dml.ag" #-}
leftToEmpty (\ct -> [StatementType (getPlaceholderTypes _insDataAddedInferredTypes ) (fromMaybe [] _returningIlistType)]) _columnTypes
{-# LINE 12132 "AstInternal.hs" #-}
-- "./TypeChecking/Dml.ag"(line 25, column 9)
_columnTypes =
{-# LINE 25 "./TypeChecking/Dml.ag" #-}
do
tys <- unwrapSetOfComposite $
getTypeAnnotation _insDataIannotatedTree
checkColumnConsistency _lhsIcat
table_
_targetColsIstrings
tys
{-# LINE 12143 "AstInternal.hs" #-}
-- "./TypeChecking/Dml.ag"(line 33, column 9)
_insDataAddedInferredTypes =
{-# LINE 33 "./TypeChecking/Dml.ag" #-}
case _insDataIannotatedTree of
Values ann [exl] ->
let fargs = map snd (fromRight [] _columnTypes ) ++ repeat TypeCheckFailed
newExl = map (\(ex,ty) -> updateAnnotation (++ [InferredType ty]) ex) $ zip exl fargs
in Values ann [newExl]
x -> x
{-# LINE 12153 "AstInternal.hs" #-}
-- "./TypeChecking/Dml.ag"(line 41, column 9)
_backTree =
{-# LINE 41 "./TypeChecking/Dml.ag" #-}
Insert ann_ table_ _targetColsIannotatedTree
_insDataAddedInferredTypes _returningIannotatedTree
{-# LINE 12159 "AstInternal.hs" #-}
-- "./TypeChecking/Dml.ag"(line 43, column 9)
_catUpdates =
{-# LINE 43 "./TypeChecking/Dml.ag" #-}
[]
{-# LINE 12164 "AstInternal.hs" #-}
-- "./TypeChecking/Dml.ag"(line 49, column 9)
_returningOlib =
{-# LINE 49 "./TypeChecking/Dml.ag" #-}
fromRight _lhsIlib $ do
atts <- catCompositeAttrs _lhsIcat relationComposites table_
updateBindings _lhsIlib _lhsIcat [LibStackIDs [("", atts)]]
{-# LINE 12171 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
Insert ann_ table_ _targetColsIannotatedTree _insDataIannotatedTree _returningIannotatedTree
{-# LINE 12176 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
Insert ann_ table_ _targetColsIoriginalTree _insDataIoriginalTree _returningIoriginalTree
{-# LINE 12181 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 12186 "AstInternal.hs" #-}
-- copy rule (down)
_targetColsOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 12191 "AstInternal.hs" #-}
-- copy rule (down)
_targetColsOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 12196 "AstInternal.hs" #-}
-- copy rule (down)
_insDataOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 12201 "AstInternal.hs" #-}
-- copy rule (down)
_insDataOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 12206 "AstInternal.hs" #-}
-- copy rule (down)
_returningOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 12211 "AstInternal.hs" #-}
( _targetColsIannotatedTree,_targetColsIoriginalTree,_targetColsIstrings) =
(targetCols_ _targetColsOcat _targetColsOlib )
( _insDataIannotatedTree,_insDataIlibUpdates,_insDataIoriginalTree) =
(insData_ _insDataOcat _insDataOlib )
( _returningIannotatedTree,_returningIlistType,_returningIoriginalTree) =
(returning_ _returningOcat _returningOlib )
in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree)))
sem_Statement_Notify :: Annotation ->
String ->
T_Statement
sem_Statement_Notify ann_ name_ =
(\ _lhsIcat
_lhsIinProducedCat
_lhsIlib ->
(let _lhsOcatUpdates :: ([CatalogUpdate])
_lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_lhsOannotatedTree :: Statement
_lhsOoriginalTree :: Statement
-- "./TypeChecking/Statements.ag"(line 73, column 9)
_libUpdates =
{-# LINE 73 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 12234 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 89, column 9)
_lhsOcatUpdates =
{-# LINE 89 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 12239 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 90, column 9)
_lhsOlibUpdates =
{-# LINE 90 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 12244 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
Notify ann_ name_
{-# LINE 12249 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
Notify ann_ name_
{-# LINE 12254 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 12259 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 12264 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree)))
sem_Statement_NullStatement :: Annotation ->
T_Statement
sem_Statement_NullStatement ann_ =
(\ _lhsIcat
_lhsIinProducedCat
_lhsIlib ->
(let _lhsOcatUpdates :: ([CatalogUpdate])
_lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_lhsOannotatedTree :: Statement
_lhsOoriginalTree :: Statement
-- "./TypeChecking/Statements.ag"(line 89, column 9)
_lhsOcatUpdates =
{-# LINE 89 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 12280 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 90, column 9)
_lhsOlibUpdates =
{-# LINE 90 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 12285 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
NullStatement ann_
{-# LINE 12290 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
NullStatement ann_
{-# LINE 12295 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 12300 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 12305 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree)))
sem_Statement_Perform :: Annotation ->
T_Expression ->
T_Statement
sem_Statement_Perform ann_ expr_ =
(\ _lhsIcat
_lhsIinProducedCat
_lhsIlib ->
(let _lhsOcatUpdates :: ([CatalogUpdate])
_lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_lhsOannotatedTree :: Statement
_lhsOoriginalTree :: Statement
_exprOcat :: Catalog
_exprOlib :: LocalIdentifierBindings
_exprIannotatedTree :: Expression
_exprIliftedColumnName :: String
_exprIoriginalTree :: Expression
-- "./TypeChecking/Statements.ag"(line 89, column 9)
_lhsOcatUpdates =
{-# LINE 89 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 12327 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 90, column 9)
_lhsOlibUpdates =
{-# LINE 90 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 12332 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
Perform ann_ _exprIannotatedTree
{-# LINE 12337 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
Perform ann_ _exprIoriginalTree
{-# LINE 12342 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 12347 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 12352 "AstInternal.hs" #-}
-- copy rule (down)
_exprOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 12357 "AstInternal.hs" #-}
-- copy rule (down)
_exprOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 12362 "AstInternal.hs" #-}
( _exprIannotatedTree,_exprIliftedColumnName,_exprIoriginalTree) =
(expr_ _exprOcat _exprOlib )
in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree)))
sem_Statement_Raise :: Annotation ->
T_RaiseType ->
String ->
T_ExpressionList ->
T_Statement
sem_Statement_Raise ann_ level_ message_ args_ =
(\ _lhsIcat
_lhsIinProducedCat
_lhsIlib ->
(let _lhsOcatUpdates :: ([CatalogUpdate])
_lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_lhsOannotatedTree :: Statement
_lhsOoriginalTree :: Statement
_levelOcat :: Catalog
_levelOlib :: LocalIdentifierBindings
_argsOcat :: Catalog
_argsOlib :: LocalIdentifierBindings
_levelIannotatedTree :: RaiseType
_levelIoriginalTree :: RaiseType
_argsIannotatedTree :: ExpressionList
_argsIoriginalTree :: ExpressionList
_argsItypeList :: ([Type])
-- "./TypeChecking/Statements.ag"(line 89, column 9)
_lhsOcatUpdates =
{-# LINE 89 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 12392 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 90, column 9)
_lhsOlibUpdates =
{-# LINE 90 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 12397 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
Raise ann_ _levelIannotatedTree message_ _argsIannotatedTree
{-# LINE 12402 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
Raise ann_ _levelIoriginalTree message_ _argsIoriginalTree
{-# LINE 12407 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 12412 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 12417 "AstInternal.hs" #-}
-- copy rule (down)
_levelOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 12422 "AstInternal.hs" #-}
-- copy rule (down)
_levelOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 12427 "AstInternal.hs" #-}
-- copy rule (down)
_argsOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 12432 "AstInternal.hs" #-}
-- copy rule (down)
_argsOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 12437 "AstInternal.hs" #-}
( _levelIannotatedTree,_levelIoriginalTree) =
(level_ _levelOcat _levelOlib )
( _argsIannotatedTree,_argsIoriginalTree,_argsItypeList) =
(args_ _argsOcat _argsOlib )
in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree)))
sem_Statement_Return :: Annotation ->
T_MaybeExpression ->
T_Statement
sem_Statement_Return ann_ value_ =
(\ _lhsIcat
_lhsIinProducedCat
_lhsIlib ->
(let _lhsOannotatedTree :: Statement
_lhsOcatUpdates :: ([CatalogUpdate])
_lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_tpe :: (Either [TypeError] Type)
_catUpdates :: ([CatalogUpdate])
_lhsOoriginalTree :: Statement
_valueOcat :: Catalog
_valueOlib :: LocalIdentifierBindings
_valueIannotatedTree :: MaybeExpression
_valueIoriginalTree :: MaybeExpression
-- "./TypeChecking/Statements.ag"(line 61, column 9)
_lhsOannotatedTree =
{-# LINE 61 "./TypeChecking/Statements.ag" #-}
annTypesAndErrors _backTree
(tpeToT _tpe )
(getErrors _tpe )
$ Just (map StatementTypeA _statementType ++
[CatUpdates _catUpdates ])
{-# LINE 12468 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 67, column 9)
_lhsOcatUpdates =
{-# LINE 67 "./TypeChecking/Statements.ag" #-}
_catUpdates
{-# LINE 12473 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 68, column 9)
_lhsOlibUpdates =
{-# LINE 68 "./TypeChecking/Statements.ag" #-}
_libUpdates
{-# LINE 12478 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 73, column 9)
_libUpdates =
{-# LINE 73 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 12483 "AstInternal.hs" #-}
-- "./TypeChecking/Plpgsql.ag"(line 12, column 9)
_tpe =
{-# LINE 12 "./TypeChecking/Plpgsql.ag" #-}
dependsOnRTpe [maybe typeBool
getTypeAnnotation
_valueIannotatedTree] $ Right $ Pseudo Void
{-# LINE 12490 "AstInternal.hs" #-}
-- "./TypeChecking/Plpgsql.ag"(line 16, column 9)
_backTree =
{-# LINE 16 "./TypeChecking/Plpgsql.ag" #-}
Return ann_ _valueIannotatedTree
{-# LINE 12495 "AstInternal.hs" #-}
-- "./TypeChecking/Plpgsql.ag"(line 17, column 9)
_catUpdates =
{-# LINE 17 "./TypeChecking/Plpgsql.ag" #-}
[]
{-# LINE 12500 "AstInternal.hs" #-}
-- "./TypeChecking/Plpgsql.ag"(line 18, column 9)
_statementType =
{-# LINE 18 "./TypeChecking/Plpgsql.ag" #-}
[]
{-# LINE 12505 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
Return ann_ _valueIannotatedTree
{-# LINE 12510 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
Return ann_ _valueIoriginalTree
{-# LINE 12515 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 12520 "AstInternal.hs" #-}
-- copy rule (down)
_valueOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 12525 "AstInternal.hs" #-}
-- copy rule (down)
_valueOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 12530 "AstInternal.hs" #-}
( _valueIannotatedTree,_valueIoriginalTree) =
(value_ _valueOcat _valueOlib )
in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree)))
sem_Statement_ReturnNext :: Annotation ->
T_Expression ->
T_Statement
sem_Statement_ReturnNext ann_ expr_ =
(\ _lhsIcat
_lhsIinProducedCat
_lhsIlib ->
(let _lhsOcatUpdates :: ([CatalogUpdate])
_lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_lhsOannotatedTree :: Statement
_lhsOoriginalTree :: Statement
_exprOcat :: Catalog
_exprOlib :: LocalIdentifierBindings
_exprIannotatedTree :: Expression
_exprIliftedColumnName :: String
_exprIoriginalTree :: Expression
-- "./TypeChecking/Statements.ag"(line 89, column 9)
_lhsOcatUpdates =
{-# LINE 89 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 12554 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 90, column 9)
_lhsOlibUpdates =
{-# LINE 90 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 12559 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
ReturnNext ann_ _exprIannotatedTree
{-# LINE 12564 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
ReturnNext ann_ _exprIoriginalTree
{-# LINE 12569 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 12574 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 12579 "AstInternal.hs" #-}
-- copy rule (down)
_exprOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 12584 "AstInternal.hs" #-}
-- copy rule (down)
_exprOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 12589 "AstInternal.hs" #-}
( _exprIannotatedTree,_exprIliftedColumnName,_exprIoriginalTree) =
(expr_ _exprOcat _exprOlib )
in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree)))
sem_Statement_ReturnQuery :: Annotation ->
T_SelectExpression ->
T_Statement
sem_Statement_ReturnQuery ann_ sel_ =
(\ _lhsIcat
_lhsIinProducedCat
_lhsIlib ->
(let _lhsOcatUpdates :: ([CatalogUpdate])
_lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_lhsOannotatedTree :: Statement
_lhsOoriginalTree :: Statement
_selOcat :: Catalog
_selOlib :: LocalIdentifierBindings
_selIannotatedTree :: SelectExpression
_selIlibUpdates :: ([LocalIdentifierBindingsUpdate])
_selIoriginalTree :: SelectExpression
-- "./TypeChecking/Statements.ag"(line 89, column 9)
_lhsOcatUpdates =
{-# LINE 89 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 12613 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 90, column 9)
_lhsOlibUpdates =
{-# LINE 90 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 12618 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
ReturnQuery ann_ _selIannotatedTree
{-# LINE 12623 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
ReturnQuery ann_ _selIoriginalTree
{-# LINE 12628 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 12633 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 12638 "AstInternal.hs" #-}
-- copy rule (down)
_selOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 12643 "AstInternal.hs" #-}
-- copy rule (down)
_selOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 12648 "AstInternal.hs" #-}
( _selIannotatedTree,_selIlibUpdates,_selIoriginalTree) =
(sel_ _selOcat _selOlib )
in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree)))
sem_Statement_SelectStatement :: Annotation ->
T_SelectExpression ->
T_Statement
sem_Statement_SelectStatement ann_ ex_ =
(\ _lhsIcat
_lhsIinProducedCat
_lhsIlib ->
(let _lhsOannotatedTree :: Statement
_lhsOcatUpdates :: ([CatalogUpdate])
_lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_tpe :: (Either [TypeError] Type)
_catUpdates :: ([CatalogUpdate])
_lhsOoriginalTree :: Statement
_exOcat :: Catalog
_exOlib :: LocalIdentifierBindings
_exIannotatedTree :: SelectExpression
_exIlibUpdates :: ([LocalIdentifierBindingsUpdate])
_exIoriginalTree :: SelectExpression
-- "./TypeChecking/Statements.ag"(line 61, column 9)
_lhsOannotatedTree =
{-# LINE 61 "./TypeChecking/Statements.ag" #-}
annTypesAndErrors _backTree
(tpeToT _tpe )
(getErrors _tpe )
$ Just (map StatementTypeA _statementType ++
[CatUpdates _catUpdates ])
{-# LINE 12678 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 67, column 9)
_lhsOcatUpdates =
{-# LINE 67 "./TypeChecking/Statements.ag" #-}
_catUpdates
{-# LINE 12683 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 68, column 9)
_lhsOlibUpdates =
{-# LINE 68 "./TypeChecking/Statements.ag" #-}
_libUpdates
{-# LINE 12688 "AstInternal.hs" #-}
-- "./TypeChecking/SelectStatement.ag"(line 14, column 9)
_tpe =
{-# LINE 14 "./TypeChecking/SelectStatement.ag" #-}
dependsOnRTpe [getTypeAnnotation _exIannotatedTree] $ Right $ Pseudo Void
{-# LINE 12693 "AstInternal.hs" #-}
-- "./TypeChecking/SelectStatement.ag"(line 15, column 9)
_statementType =
{-# LINE 15 "./TypeChecking/SelectStatement.ag" #-}
[StatementType (getPlaceholderTypes _exIannotatedTree) $ leftToEmpty id $
unwrapSetOfComposite $
getTypeAnnotation _exIannotatedTree]
{-# LINE 12700 "AstInternal.hs" #-}
-- "./TypeChecking/SelectStatement.ag"(line 18, column 9)
_backTree =
{-# LINE 18 "./TypeChecking/SelectStatement.ag" #-}
SelectStatement ann_ _exIannotatedTree
{-# LINE 12705 "AstInternal.hs" #-}
-- "./TypeChecking/SelectStatement.ag"(line 19, column 9)
_catUpdates =
{-# LINE 19 "./TypeChecking/SelectStatement.ag" #-}
[]
{-# LINE 12710 "AstInternal.hs" #-}
-- "./TypeChecking/SelectLists.ag"(line 79, column 9)
_libUpdates =
{-# LINE 79 "./TypeChecking/SelectLists.ag" #-}
_exIlibUpdates
{-# LINE 12715 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
SelectStatement ann_ _exIannotatedTree
{-# LINE 12720 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
SelectStatement ann_ _exIoriginalTree
{-# LINE 12725 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 12730 "AstInternal.hs" #-}
-- copy rule (down)
_exOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 12735 "AstInternal.hs" #-}
-- copy rule (down)
_exOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 12740 "AstInternal.hs" #-}
( _exIannotatedTree,_exIlibUpdates,_exIoriginalTree) =
(ex_ _exOcat _exOlib )
in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree)))
sem_Statement_Set :: Annotation ->
String ->
([SetValue]) ->
T_Statement
sem_Statement_Set ann_ name_ values_ =
(\ _lhsIcat
_lhsIinProducedCat
_lhsIlib ->
(let _lhsOcatUpdates :: ([CatalogUpdate])
_lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_lhsOannotatedTree :: Statement
_lhsOoriginalTree :: Statement
-- "./TypeChecking/Statements.ag"(line 73, column 9)
_libUpdates =
{-# LINE 73 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 12760 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 89, column 9)
_lhsOcatUpdates =
{-# LINE 89 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 12765 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 90, column 9)
_lhsOlibUpdates =
{-# LINE 90 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 12770 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
Set ann_ name_ values_
{-# LINE 12775 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
Set ann_ name_ values_
{-# LINE 12780 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 12785 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 12790 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree)))
sem_Statement_Truncate :: Annotation ->
T_StringList ->
T_RestartIdentity ->
T_Cascade ->
T_Statement
sem_Statement_Truncate ann_ tables_ restartIdentity_ cascade_ =
(\ _lhsIcat
_lhsIinProducedCat
_lhsIlib ->
(let _lhsOcatUpdates :: ([CatalogUpdate])
_lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_lhsOannotatedTree :: Statement
_lhsOoriginalTree :: Statement
_tablesOcat :: Catalog
_tablesOlib :: LocalIdentifierBindings
_restartIdentityOcat :: Catalog
_restartIdentityOlib :: LocalIdentifierBindings
_cascadeOcat :: Catalog
_cascadeOlib :: LocalIdentifierBindings
_tablesIannotatedTree :: StringList
_tablesIoriginalTree :: StringList
_tablesIstrings :: ([String])
_restartIdentityIannotatedTree :: RestartIdentity
_restartIdentityIoriginalTree :: RestartIdentity
_cascadeIannotatedTree :: Cascade
_cascadeIoriginalTree :: Cascade
-- "./TypeChecking/Statements.ag"(line 89, column 9)
_lhsOcatUpdates =
{-# LINE 89 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 12822 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 90, column 9)
_lhsOlibUpdates =
{-# LINE 90 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 12827 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
Truncate ann_ _tablesIannotatedTree _restartIdentityIannotatedTree _cascadeIannotatedTree
{-# LINE 12832 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
Truncate ann_ _tablesIoriginalTree _restartIdentityIoriginalTree _cascadeIoriginalTree
{-# LINE 12837 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 12842 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 12847 "AstInternal.hs" #-}
-- copy rule (down)
_tablesOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 12852 "AstInternal.hs" #-}
-- copy rule (down)
_tablesOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 12857 "AstInternal.hs" #-}
-- copy rule (down)
_restartIdentityOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 12862 "AstInternal.hs" #-}
-- copy rule (down)
_restartIdentityOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 12867 "AstInternal.hs" #-}
-- copy rule (down)
_cascadeOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 12872 "AstInternal.hs" #-}
-- copy rule (down)
_cascadeOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 12877 "AstInternal.hs" #-}
( _tablesIannotatedTree,_tablesIoriginalTree,_tablesIstrings) =
(tables_ _tablesOcat _tablesOlib )
( _restartIdentityIannotatedTree,_restartIdentityIoriginalTree) =
(restartIdentity_ _restartIdentityOcat _restartIdentityOlib )
( _cascadeIannotatedTree,_cascadeIoriginalTree) =
(cascade_ _cascadeOcat _cascadeOlib )
in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree)))
sem_Statement_Update :: Annotation ->
String ->
T_SetClauseList ->
T_MaybeBoolExpression ->
T_MaybeSelectList ->
T_Statement
sem_Statement_Update ann_ table_ assigns_ whr_ returning_ =
(\ _lhsIcat
_lhsIinProducedCat
_lhsIlib ->
(let _lhsOannotatedTree :: Statement
_lhsOcatUpdates :: ([CatalogUpdate])
_lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_tpe :: (Either [TypeError] Type)
_assignWInferredTypes :: SetClauseList
_catUpdates :: ([CatalogUpdate])
_whrOlib :: LocalIdentifierBindings
_assignsOlib :: LocalIdentifierBindings
_returningOlib :: LocalIdentifierBindings
_lhsOoriginalTree :: Statement
_assignsOcat :: Catalog
_whrOcat :: Catalog
_returningOcat :: Catalog
_assignsIannotatedTree :: SetClauseList
_assignsIoriginalTree :: SetClauseList
_assignsIpairs :: ([(String,Type)])
_assignsIrowSetErrors :: ([TypeError])
_whrIannotatedTree :: MaybeBoolExpression
_whrIoriginalTree :: MaybeBoolExpression
_returningIannotatedTree :: MaybeSelectList
_returningIlistType :: (Maybe [(String,Type)])
_returningIoriginalTree :: MaybeSelectList
-- "./TypeChecking/Statements.ag"(line 61, column 9)
_lhsOannotatedTree =
{-# LINE 61 "./TypeChecking/Statements.ag" #-}
annTypesAndErrors _backTree
(tpeToT _tpe )
(getErrors _tpe )
$ Just (map StatementTypeA _statementType ++
[CatUpdates _catUpdates ])
{-# LINE 12925 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 67, column 9)
_lhsOcatUpdates =
{-# LINE 67 "./TypeChecking/Statements.ag" #-}
_catUpdates
{-# LINE 12930 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 68, column 9)
_lhsOlibUpdates =
{-# LINE 68 "./TypeChecking/Statements.ag" #-}
_libUpdates
{-# LINE 12935 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 73, column 9)
_libUpdates =
{-# LINE 73 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 12940 "AstInternal.hs" #-}
-- "./TypeChecking/Dml.ag"(line 65, column 9)
_tpe =
{-# LINE 65 "./TypeChecking/Dml.ag" #-}
do
checkRelationExists _lhsIcat table_
dependsOnRTpe (map snd _assignsIpairs) $ do
_columnTypes
liftErrors _assignsIrowSetErrors
return $ Pseudo Void
{-# LINE 12950 "AstInternal.hs" #-}
-- "./TypeChecking/Dml.ag"(line 72, column 9)
_statementType =
{-# LINE 72 "./TypeChecking/Dml.ag" #-}
leftToEmpty (\ct -> [StatementType (getPlaceholderTypes _assignWInferredTypes
++ getPlaceholderTypes _whrIannotatedTree)
(fromMaybe [] _returningIlistType)])
_columnTypes
{-# LINE 12958 "AstInternal.hs" #-}
-- "./TypeChecking/Dml.ag"(line 78, column 9)
_columnTypes =
{-# LINE 78 "./TypeChecking/Dml.ag" #-}
checkColumnConsistency _lhsIcat
table_
(map fst _assignsIpairs)
_assignsIpairs
{-# LINE 12966 "AstInternal.hs" #-}
-- "./TypeChecking/Dml.ag"(line 84, column 9)
_assignWInferredTypes =
{-# LINE 84 "./TypeChecking/Dml.ag" #-}
let colTypes :: [Type]
colTypes = (map snd $ fromRight [] _columnTypes )
in setInferredTypesG colTypes _assignsIannotatedTree
{-# LINE 12973 "AstInternal.hs" #-}
-- "./TypeChecking/Dml.ag"(line 89, column 9)
_backTree =
{-# LINE 89 "./TypeChecking/Dml.ag" #-}
Update ann_
table_
_assignWInferredTypes
_whrIannotatedTree
_returningIannotatedTree
{-# LINE 12982 "AstInternal.hs" #-}
-- "./TypeChecking/Dml.ag"(line 94, column 9)
_catUpdates =
{-# LINE 94 "./TypeChecking/Dml.ag" #-}
[]
{-# LINE 12987 "AstInternal.hs" #-}
-- "./TypeChecking/Dml.ag"(line 114, column 9)
_lib =
{-# LINE 114 "./TypeChecking/Dml.ag" #-}
fromRight _lhsIlib $ do
ct <- catCompositeAttrs _lhsIcat
relationComposites
table_
updateBindings _lhsIlib _lhsIcat [LibStackIDs [("", ct)]]
{-# LINE 12996 "AstInternal.hs" #-}
-- "./TypeChecking/Dml.ag"(line 120, column 9)
_whrOlib =
{-# LINE 120 "./TypeChecking/Dml.ag" #-}
_lib
{-# LINE 13001 "AstInternal.hs" #-}
-- "./TypeChecking/Dml.ag"(line 121, column 9)
_assignsOlib =
{-# LINE 121 "./TypeChecking/Dml.ag" #-}
_lib
{-# LINE 13006 "AstInternal.hs" #-}
-- "./TypeChecking/Dml.ag"(line 122, column 9)
_returningOlib =
{-# LINE 122 "./TypeChecking/Dml.ag" #-}
_lib
{-# LINE 13011 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
Update ann_ table_ _assignsIannotatedTree _whrIannotatedTree _returningIannotatedTree
{-# LINE 13016 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
Update ann_ table_ _assignsIoriginalTree _whrIoriginalTree _returningIoriginalTree
{-# LINE 13021 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 13026 "AstInternal.hs" #-}
-- copy rule (down)
_assignsOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 13031 "AstInternal.hs" #-}
-- copy rule (down)
_whrOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 13036 "AstInternal.hs" #-}
-- copy rule (down)
_returningOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 13041 "AstInternal.hs" #-}
( _assignsIannotatedTree,_assignsIoriginalTree,_assignsIpairs,_assignsIrowSetErrors) =
(assigns_ _assignsOcat _assignsOlib )
( _whrIannotatedTree,_whrIoriginalTree) =
(whr_ _whrOcat _whrOlib )
( _returningIannotatedTree,_returningIlistType,_returningIoriginalTree) =
(returning_ _returningOcat _returningOlib )
in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree)))
sem_Statement_WhileStatement :: Annotation ->
T_Expression ->
T_StatementList ->
T_Statement
sem_Statement_WhileStatement ann_ expr_ sts_ =
(\ _lhsIcat
_lhsIinProducedCat
_lhsIlib ->
(let _lhsOcatUpdates :: ([CatalogUpdate])
_lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_stsOcatUpdates :: ([CatalogUpdate])
_stsOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_lhsOannotatedTree :: Statement
_lhsOoriginalTree :: Statement
_exprOcat :: Catalog
_exprOlib :: LocalIdentifierBindings
_stsOcat :: Catalog
_stsOlib :: LocalIdentifierBindings
_exprIannotatedTree :: Expression
_exprIliftedColumnName :: String
_exprIoriginalTree :: Expression
_stsIannotatedTree :: StatementList
_stsIoriginalTree :: StatementList
_stsIproducedCat :: Catalog
_stsIproducedLib :: LocalIdentifierBindings
-- "./TypeChecking/Statements.ag"(line 89, column 9)
_lhsOcatUpdates =
{-# LINE 89 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 13078 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 90, column 9)
_lhsOlibUpdates =
{-# LINE 90 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 13083 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 110, column 9)
_stsOcatUpdates =
{-# LINE 110 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 13088 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 111, column 9)
_stsOlibUpdates =
{-# LINE 111 "./TypeChecking/Statements.ag" #-}
[]
{-# LINE 13093 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
WhileStatement ann_ _exprIannotatedTree _stsIannotatedTree
{-# LINE 13098 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
WhileStatement ann_ _exprIoriginalTree _stsIoriginalTree
{-# LINE 13103 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 13108 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 13113 "AstInternal.hs" #-}
-- copy rule (down)
_exprOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 13118 "AstInternal.hs" #-}
-- copy rule (down)
_exprOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 13123 "AstInternal.hs" #-}
-- copy rule (down)
_stsOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 13128 "AstInternal.hs" #-}
-- copy rule (down)
_stsOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 13133 "AstInternal.hs" #-}
( _exprIannotatedTree,_exprIliftedColumnName,_exprIoriginalTree) =
(expr_ _exprOcat _exprOlib )
( _stsIannotatedTree,_stsIoriginalTree,_stsIproducedCat,_stsIproducedLib) =
(sts_ _stsOcat _stsOcatUpdates _stsOlib _stsOlibUpdates )
in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree)))
-- StatementList -----------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
catUpdates : [CatalogUpdate]
lib : LocalIdentifierBindings
libUpdates : [LocalIdentifierBindingsUpdate]
synthesized attributes:
annotatedTree : SELF
originalTree : SELF
producedCat : Catalog
producedLib : LocalIdentifierBindings
alternatives:
alternative Cons:
child hd : Statement
child tl : StatementList
visit 0:
local newCat : _
local newLib : _
local annotatedTree : _
local originalTree : _
alternative Nil:
visit 0:
local newCat : _
local newLib : _
local annotatedTree : _
local originalTree : _
-}
type StatementList = [(Statement)]
-- cata
sem_StatementList :: StatementList ->
T_StatementList
sem_StatementList list =
(Prelude.foldr sem_StatementList_Cons sem_StatementList_Nil (Prelude.map sem_Statement list) )
-- semantic domain
type T_StatementList = Catalog ->
([CatalogUpdate]) ->
LocalIdentifierBindings ->
([LocalIdentifierBindingsUpdate]) ->
( StatementList,StatementList,Catalog,LocalIdentifierBindings)
data Inh_StatementList = Inh_StatementList {cat_Inh_StatementList :: Catalog,catUpdates_Inh_StatementList :: [CatalogUpdate],lib_Inh_StatementList :: LocalIdentifierBindings,libUpdates_Inh_StatementList :: [LocalIdentifierBindingsUpdate]}
data Syn_StatementList = Syn_StatementList {annotatedTree_Syn_StatementList :: StatementList,originalTree_Syn_StatementList :: StatementList,producedCat_Syn_StatementList :: Catalog,producedLib_Syn_StatementList :: LocalIdentifierBindings}
wrap_StatementList :: T_StatementList ->
Inh_StatementList ->
Syn_StatementList
wrap_StatementList sem (Inh_StatementList _lhsIcat _lhsIcatUpdates _lhsIlib _lhsIlibUpdates ) =
(let ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOproducedCat,_lhsOproducedLib) =
(sem _lhsIcat _lhsIcatUpdates _lhsIlib _lhsIlibUpdates )
in (Syn_StatementList _lhsOannotatedTree _lhsOoriginalTree _lhsOproducedCat _lhsOproducedLib ))
sem_StatementList_Cons :: T_Statement ->
T_StatementList ->
T_StatementList
sem_StatementList_Cons hd_ tl_ =
(\ _lhsIcat
_lhsIcatUpdates
_lhsIlib
_lhsIlibUpdates ->
(let _hdOcat :: Catalog
_tlOcat :: Catalog
_hdOlib :: LocalIdentifierBindings
_tlOlib :: LocalIdentifierBindings
_lhsOproducedCat :: Catalog
_lhsOproducedLib :: LocalIdentifierBindings
_tlOcatUpdates :: ([CatalogUpdate])
_tlOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_hdOinProducedCat :: Catalog
_lhsOannotatedTree :: StatementList
_lhsOoriginalTree :: StatementList
_hdIannotatedTree :: Statement
_hdIcatUpdates :: ([CatalogUpdate])
_hdIlibUpdates :: ([LocalIdentifierBindingsUpdate])
_hdIoriginalTree :: Statement
_tlIannotatedTree :: StatementList
_tlIoriginalTree :: StatementList
_tlIproducedCat :: Catalog
_tlIproducedLib :: LocalIdentifierBindings
-- "./TypeChecking/Statements.ag"(line 36, column 9)
_newCat =
{-# LINE 36 "./TypeChecking/Statements.ag" #-}
fromRight _lhsIcat $ updateCatalog _lhsIcat _lhsIcatUpdates
{-# LINE 13220 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 37, column 9)
_newLib =
{-# LINE 37 "./TypeChecking/Statements.ag" #-}
fromRight _lhsIlib $ updateBindings _lhsIlib _lhsIcat _lhsIlibUpdates
{-# LINE 13225 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 39, column 9)
_hdOcat =
{-# LINE 39 "./TypeChecking/Statements.ag" #-}
_newCat
{-# LINE 13230 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 40, column 9)
_tlOcat =
{-# LINE 40 "./TypeChecking/Statements.ag" #-}
_newCat
{-# LINE 13235 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 41, column 9)
_hdOlib =
{-# LINE 41 "./TypeChecking/Statements.ag" #-}
_newLib
{-# LINE 13240 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 42, column 9)
_tlOlib =
{-# LINE 42 "./TypeChecking/Statements.ag" #-}
_newLib
{-# LINE 13245 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 46, column 9)
_lhsOproducedCat =
{-# LINE 46 "./TypeChecking/Statements.ag" #-}
_tlIproducedCat
{-# LINE 13250 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 47, column 9)
_lhsOproducedLib =
{-# LINE 47 "./TypeChecking/Statements.ag" #-}
_tlIproducedLib
{-# LINE 13255 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 50, column 9)
_tlOcatUpdates =
{-# LINE 50 "./TypeChecking/Statements.ag" #-}
_hdIcatUpdates
{-# LINE 13260 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 51, column 9)
_tlOlibUpdates =
{-# LINE 51 "./TypeChecking/Statements.ag" #-}
_hdIlibUpdates
{-# LINE 13265 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 76, column 12)
_hdOinProducedCat =
{-# LINE 76 "./TypeChecking/Statements.ag" #-}
_tlIproducedCat
{-# LINE 13270 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
(:) _hdIannotatedTree _tlIannotatedTree
{-# LINE 13275 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
(:) _hdIoriginalTree _tlIoriginalTree
{-# LINE 13280 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 13285 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 13290 "AstInternal.hs" #-}
( _hdIannotatedTree,_hdIcatUpdates,_hdIlibUpdates,_hdIoriginalTree) =
(hd_ _hdOcat _hdOinProducedCat _hdOlib )
( _tlIannotatedTree,_tlIoriginalTree,_tlIproducedCat,_tlIproducedLib) =
(tl_ _tlOcat _tlOcatUpdates _tlOlib _tlOlibUpdates )
in ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOproducedCat,_lhsOproducedLib)))
sem_StatementList_Nil :: T_StatementList
sem_StatementList_Nil =
(\ _lhsIcat
_lhsIcatUpdates
_lhsIlib
_lhsIlibUpdates ->
(let _lhsOproducedCat :: Catalog
_lhsOproducedLib :: LocalIdentifierBindings
_lhsOannotatedTree :: StatementList
_lhsOoriginalTree :: StatementList
-- "./TypeChecking/Statements.ag"(line 36, column 9)
_newCat =
{-# LINE 36 "./TypeChecking/Statements.ag" #-}
fromRight _lhsIcat $ updateCatalog _lhsIcat _lhsIcatUpdates
{-# LINE 13310 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 37, column 9)
_newLib =
{-# LINE 37 "./TypeChecking/Statements.ag" #-}
fromRight _lhsIlib $ updateBindings _lhsIlib _lhsIcat _lhsIlibUpdates
{-# LINE 13315 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 53, column 9)
_lhsOproducedCat =
{-# LINE 53 "./TypeChecking/Statements.ag" #-}
_newCat
{-# LINE 13320 "AstInternal.hs" #-}
-- "./TypeChecking/Statements.ag"(line 54, column 9)
_lhsOproducedLib =
{-# LINE 54 "./TypeChecking/Statements.ag" #-}
_newLib
{-# LINE 13325 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
[]
{-# LINE 13330 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
[]
{-# LINE 13335 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 13340 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 13345 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOproducedCat,_lhsOproducedLib)))
-- StringList --------------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
originalTree : SELF
strings : [String]
alternatives:
alternative Cons:
child hd : {String}
child tl : StringList
visit 0:
local annotatedTree : _
local originalTree : _
alternative Nil:
visit 0:
local annotatedTree : _
local originalTree : _
-}
type StringList = [(String)]
-- cata
sem_StringList :: StringList ->
T_StringList
sem_StringList list =
(Prelude.foldr sem_StringList_Cons sem_StringList_Nil list )
-- semantic domain
type T_StringList = Catalog ->
LocalIdentifierBindings ->
( StringList,StringList,([String]))
data Inh_StringList = Inh_StringList {cat_Inh_StringList :: Catalog,lib_Inh_StringList :: LocalIdentifierBindings}
data Syn_StringList = Syn_StringList {annotatedTree_Syn_StringList :: StringList,originalTree_Syn_StringList :: StringList,strings_Syn_StringList :: [String]}
wrap_StringList :: T_StringList ->
Inh_StringList ->
Syn_StringList
wrap_StringList sem (Inh_StringList _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOstrings) =
(sem _lhsIcat _lhsIlib )
in (Syn_StringList _lhsOannotatedTree _lhsOoriginalTree _lhsOstrings ))
sem_StringList_Cons :: String ->
T_StringList ->
T_StringList
sem_StringList_Cons hd_ tl_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOstrings :: ([String])
_lhsOannotatedTree :: StringList
_lhsOoriginalTree :: StringList
_tlOcat :: Catalog
_tlOlib :: LocalIdentifierBindings
_tlIannotatedTree :: StringList
_tlIoriginalTree :: StringList
_tlIstrings :: ([String])
-- "./TypeChecking/Misc.ag"(line 67, column 10)
_lhsOstrings =
{-# LINE 67 "./TypeChecking/Misc.ag" #-}
hd_ : _tlIstrings
{-# LINE 13406 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
(:) hd_ _tlIannotatedTree
{-# LINE 13411 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
(:) hd_ _tlIoriginalTree
{-# LINE 13416 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 13421 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 13426 "AstInternal.hs" #-}
-- copy rule (down)
_tlOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 13431 "AstInternal.hs" #-}
-- copy rule (down)
_tlOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 13436 "AstInternal.hs" #-}
( _tlIannotatedTree,_tlIoriginalTree,_tlIstrings) =
(tl_ _tlOcat _tlOlib )
in ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOstrings)))
sem_StringList_Nil :: T_StringList
sem_StringList_Nil =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOstrings :: ([String])
_lhsOannotatedTree :: StringList
_lhsOoriginalTree :: StringList
-- "./TypeChecking/Misc.ag"(line 68, column 9)
_lhsOstrings =
{-# LINE 68 "./TypeChecking/Misc.ag" #-}
[]
{-# LINE 13451 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
[]
{-# LINE 13456 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
[]
{-# LINE 13461 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 13466 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 13471 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOstrings)))
-- StringTypeNameListPair --------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
fnSig : (String,[Type])
originalTree : SELF
alternatives:
alternative Tuple:
child x1 : {String}
child x2 : TypeNameList
visit 0:
local annotatedTree : _
local originalTree : _
-}
type StringTypeNameListPair = ( (String),(TypeNameList))
-- cata
sem_StringTypeNameListPair :: StringTypeNameListPair ->
T_StringTypeNameListPair
sem_StringTypeNameListPair ( x1,x2) =
(sem_StringTypeNameListPair_Tuple x1 (sem_TypeNameList x2 ) )
-- semantic domain
type T_StringTypeNameListPair = Catalog ->
LocalIdentifierBindings ->
( StringTypeNameListPair,((String,[Type])),StringTypeNameListPair)
data Inh_StringTypeNameListPair = Inh_StringTypeNameListPair {cat_Inh_StringTypeNameListPair :: Catalog,lib_Inh_StringTypeNameListPair :: LocalIdentifierBindings}
data Syn_StringTypeNameListPair = Syn_StringTypeNameListPair {annotatedTree_Syn_StringTypeNameListPair :: StringTypeNameListPair,fnSig_Syn_StringTypeNameListPair :: (String,[Type]),originalTree_Syn_StringTypeNameListPair :: StringTypeNameListPair}
wrap_StringTypeNameListPair :: T_StringTypeNameListPair ->
Inh_StringTypeNameListPair ->
Syn_StringTypeNameListPair
wrap_StringTypeNameListPair sem (Inh_StringTypeNameListPair _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOfnSig,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_StringTypeNameListPair _lhsOannotatedTree _lhsOfnSig _lhsOoriginalTree ))
sem_StringTypeNameListPair_Tuple :: String ->
T_TypeNameList ->
T_StringTypeNameListPair
sem_StringTypeNameListPair_Tuple x1_ x2_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOfnSig :: ((String,[Type]))
_lhsOannotatedTree :: StringTypeNameListPair
_lhsOoriginalTree :: StringTypeNameListPair
_x2Ocat :: Catalog
_x2Olib :: LocalIdentifierBindings
_x2IannotatedTree :: TypeNameList
_x2InamedTypes :: ([Type])
_x2IoriginalTree :: TypeNameList
-- "./TypeChecking/Drops.ag"(line 25, column 13)
_lhsOfnSig =
{-# LINE 25 "./TypeChecking/Drops.ag" #-}
(x1_, _x2InamedTypes)
{-# LINE 13528 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
(x1_,_x2IannotatedTree)
{-# LINE 13533 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
(x1_,_x2IoriginalTree)
{-# LINE 13538 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 13543 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 13548 "AstInternal.hs" #-}
-- copy rule (down)
_x2Ocat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 13553 "AstInternal.hs" #-}
-- copy rule (down)
_x2Olib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 13558 "AstInternal.hs" #-}
( _x2IannotatedTree,_x2InamedTypes,_x2IoriginalTree) =
(x2_ _x2Ocat _x2Olib )
in ( _lhsOannotatedTree,_lhsOfnSig,_lhsOoriginalTree)))
-- StringTypeNameListPairList ----------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
fnSigs : [(String,[Type])]
originalTree : SELF
alternatives:
alternative Cons:
child hd : StringTypeNameListPair
child tl : StringTypeNameListPairList
visit 0:
local annotatedTree : _
local originalTree : _
alternative Nil:
visit 0:
local annotatedTree : _
local originalTree : _
-}
type StringTypeNameListPairList = [(StringTypeNameListPair)]
-- cata
sem_StringTypeNameListPairList :: StringTypeNameListPairList ->
T_StringTypeNameListPairList
sem_StringTypeNameListPairList list =
(Prelude.foldr sem_StringTypeNameListPairList_Cons sem_StringTypeNameListPairList_Nil (Prelude.map sem_StringTypeNameListPair list) )
-- semantic domain
type T_StringTypeNameListPairList = Catalog ->
LocalIdentifierBindings ->
( StringTypeNameListPairList,([(String,[Type])]),StringTypeNameListPairList)
data Inh_StringTypeNameListPairList = Inh_StringTypeNameListPairList {cat_Inh_StringTypeNameListPairList :: Catalog,lib_Inh_StringTypeNameListPairList :: LocalIdentifierBindings}
data Syn_StringTypeNameListPairList = Syn_StringTypeNameListPairList {annotatedTree_Syn_StringTypeNameListPairList :: StringTypeNameListPairList,fnSigs_Syn_StringTypeNameListPairList :: [(String,[Type])],originalTree_Syn_StringTypeNameListPairList :: StringTypeNameListPairList}
wrap_StringTypeNameListPairList :: T_StringTypeNameListPairList ->
Inh_StringTypeNameListPairList ->
Syn_StringTypeNameListPairList
wrap_StringTypeNameListPairList sem (Inh_StringTypeNameListPairList _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOfnSigs,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_StringTypeNameListPairList _lhsOannotatedTree _lhsOfnSigs _lhsOoriginalTree ))
sem_StringTypeNameListPairList_Cons :: T_StringTypeNameListPair ->
T_StringTypeNameListPairList ->
T_StringTypeNameListPairList
sem_StringTypeNameListPairList_Cons hd_ tl_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOfnSigs :: ([(String,[Type])])
_lhsOannotatedTree :: StringTypeNameListPairList
_lhsOoriginalTree :: StringTypeNameListPairList
_hdOcat :: Catalog
_hdOlib :: LocalIdentifierBindings
_tlOcat :: Catalog
_tlOlib :: LocalIdentifierBindings
_hdIannotatedTree :: StringTypeNameListPair
_hdIfnSig :: ((String,[Type]))
_hdIoriginalTree :: StringTypeNameListPair
_tlIannotatedTree :: StringTypeNameListPairList
_tlIfnSigs :: ([(String,[Type])])
_tlIoriginalTree :: StringTypeNameListPairList
-- "./TypeChecking/Drops.ag"(line 20, column 12)
_lhsOfnSigs =
{-# LINE 20 "./TypeChecking/Drops.ag" #-}
_hdIfnSig : _tlIfnSigs
{-# LINE 13626 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
(:) _hdIannotatedTree _tlIannotatedTree
{-# LINE 13631 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
(:) _hdIoriginalTree _tlIoriginalTree
{-# LINE 13636 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 13641 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 13646 "AstInternal.hs" #-}
-- copy rule (down)
_hdOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 13651 "AstInternal.hs" #-}
-- copy rule (down)
_hdOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 13656 "AstInternal.hs" #-}
-- copy rule (down)
_tlOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 13661 "AstInternal.hs" #-}
-- copy rule (down)
_tlOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 13666 "AstInternal.hs" #-}
( _hdIannotatedTree,_hdIfnSig,_hdIoriginalTree) =
(hd_ _hdOcat _hdOlib )
( _tlIannotatedTree,_tlIfnSigs,_tlIoriginalTree) =
(tl_ _tlOcat _tlOlib )
in ( _lhsOannotatedTree,_lhsOfnSigs,_lhsOoriginalTree)))
sem_StringTypeNameListPairList_Nil :: T_StringTypeNameListPairList
sem_StringTypeNameListPairList_Nil =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOfnSigs :: ([(String,[Type])])
_lhsOannotatedTree :: StringTypeNameListPairList
_lhsOoriginalTree :: StringTypeNameListPairList
-- "./TypeChecking/Drops.ag"(line 21, column 11)
_lhsOfnSigs =
{-# LINE 21 "./TypeChecking/Drops.ag" #-}
[]
{-# LINE 13683 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
[]
{-# LINE 13688 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
[]
{-# LINE 13693 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 13698 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 13703 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOfnSigs,_lhsOoriginalTree)))
-- TableAlias --------------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
originalTree : SELF
alternatives:
alternative FullAlias:
child alias : {String}
child cols : {[String]}
visit 0:
local annotatedTree : _
local originalTree : _
alternative NoAlias:
visit 0:
local annotatedTree : _
local originalTree : _
alternative TableAlias:
child alias : {String}
visit 0:
local annotatedTree : _
local originalTree : _
-}
data TableAlias = FullAlias (String) ([String])
| NoAlias
| TableAlias (String)
deriving ( Data,Eq,Show,Typeable)
-- cata
sem_TableAlias :: TableAlias ->
T_TableAlias
sem_TableAlias (FullAlias _alias _cols ) =
(sem_TableAlias_FullAlias _alias _cols )
sem_TableAlias (NoAlias ) =
(sem_TableAlias_NoAlias )
sem_TableAlias (TableAlias _alias ) =
(sem_TableAlias_TableAlias _alias )
-- semantic domain
type T_TableAlias = Catalog ->
LocalIdentifierBindings ->
( TableAlias,TableAlias)
data Inh_TableAlias = Inh_TableAlias {cat_Inh_TableAlias :: Catalog,lib_Inh_TableAlias :: LocalIdentifierBindings}
data Syn_TableAlias = Syn_TableAlias {annotatedTree_Syn_TableAlias :: TableAlias,originalTree_Syn_TableAlias :: TableAlias}
wrap_TableAlias :: T_TableAlias ->
Inh_TableAlias ->
Syn_TableAlias
wrap_TableAlias sem (Inh_TableAlias _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_TableAlias _lhsOannotatedTree _lhsOoriginalTree ))
sem_TableAlias_FullAlias :: String ->
([String]) ->
T_TableAlias
sem_TableAlias_FullAlias alias_ cols_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: TableAlias
_lhsOoriginalTree :: TableAlias
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
FullAlias alias_ cols_
{-# LINE 13769 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
FullAlias alias_ cols_
{-# LINE 13774 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 13779 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 13784 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
sem_TableAlias_NoAlias :: T_TableAlias
sem_TableAlias_NoAlias =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: TableAlias
_lhsOoriginalTree :: TableAlias
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
NoAlias
{-# LINE 13796 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
NoAlias
{-# LINE 13801 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 13806 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 13811 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
sem_TableAlias_TableAlias :: String ->
T_TableAlias
sem_TableAlias_TableAlias alias_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: TableAlias
_lhsOoriginalTree :: TableAlias
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
TableAlias alias_
{-# LINE 13824 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
TableAlias alias_
{-# LINE 13829 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 13834 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 13839 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
-- TableRef ----------------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
jlibUpdates : [LocalIdentifierBindingsUpdate]
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
idLookups : [(String,Type)]
libUpdates : [LocalIdentifierBindingsUpdate]
originalTree : SELF
qidLookups : [(String,[(String,Type)])]
qstarExpansion : [(String,[(String,Type)])]
starExpansion : [(String,Type)]
alternatives:
alternative JoinedTref:
child ann : {Annotation}
child tbl : TableRef
child nat : Natural
child joinType : JoinType
child tbl1 : TableRef
child onExpr : OnExpr
child alias : TableAlias
visit 0:
local libUpdates : _
local errs : _
local removeJoinAttrs : _
local ejoinAttrs : {Either [TypeError] [(String,Type)]}
local joinNames : _
local joinAttrs : _
local idLookups : {[(String,Type)]}
local qidLookups : {[(String,[(String,Type)])]}
local starExpansion : {[(String,Type)]}
local qstarExpansion : {[(String,[(String,Type)])]}
local newLib : _
local backTree : _
local annotatedTree : _
local originalTree : _
alternative SubTref:
child ann : {Annotation}
child sel : SelectExpression
child alias : TableAlias
visit 0:
local libUpdates : _
local errs : _
local selectAttrs : {Either [TypeError] [(String,Type)]}
local idLookups : {[(String,Type)]}
local qidLookups : {[(String,[(String,Type)])]}
local starExpansion : {[(String,Type)]}
local qstarExpansion : {[(String,[(String,Type)])]}
local backTree : _
local annotatedTree : _
local originalTree : _
alternative Tref:
child ann : {Annotation}
child tbl : {String}
child alias : TableAlias
visit 0:
local libUpdates : _
local errs : _
local relType : {Either [TypeError] ([(String, Type)], [(String, Type)])}
local relType1 : _
local pAttrs : _
local sAttrs : _
local idLookups : {[(String,Type)]}
local alias : _
local qidLookups : {[(String,[(String,Type)])]}
local starExpansion : {[(String,Type)]}
local qstarExpansion : {[(String,[(String,Type)])]}
local backTree : _
local annotatedTree : _
local originalTree : _
alternative TrefFun:
child ann : {Annotation}
child fn : Expression
child alias : TableAlias
visit 0:
local libUpdates : _
local errs : _
local eqfunIdens : {Either [TypeError] (String,[(String,Type)])}
local qfunIdens : _
local alias2 : _
local funIdens : _
local alias : _
local idLookups : {[(String,Type)]}
local qidLookups : {[(String,[(String,Type)])]}
local starExpansion : {[(String,Type)]}
local qstarExpansion : {[(String,[(String,Type)])]}
local backTree : _
local annotatedTree : _
local originalTree : _
-}
data TableRef = JoinedTref (Annotation) (TableRef) (Natural) (JoinType) (TableRef) (OnExpr) (TableAlias)
| SubTref (Annotation) (SelectExpression) (TableAlias)
| Tref (Annotation) (String) (TableAlias)
| TrefFun (Annotation) (Expression) (TableAlias)
deriving ( Data,Eq,Show,Typeable)
-- cata
sem_TableRef :: TableRef ->
T_TableRef
sem_TableRef (JoinedTref _ann _tbl _nat _joinType _tbl1 _onExpr _alias ) =
(sem_TableRef_JoinedTref _ann (sem_TableRef _tbl ) (sem_Natural _nat ) (sem_JoinType _joinType ) (sem_TableRef _tbl1 ) (sem_OnExpr _onExpr ) (sem_TableAlias _alias ) )
sem_TableRef (SubTref _ann _sel _alias ) =
(sem_TableRef_SubTref _ann (sem_SelectExpression _sel ) (sem_TableAlias _alias ) )
sem_TableRef (Tref _ann _tbl _alias ) =
(sem_TableRef_Tref _ann _tbl (sem_TableAlias _alias ) )
sem_TableRef (TrefFun _ann _fn _alias ) =
(sem_TableRef_TrefFun _ann (sem_Expression _fn ) (sem_TableAlias _alias ) )
-- semantic domain
type T_TableRef = Catalog ->
([LocalIdentifierBindingsUpdate]) ->
LocalIdentifierBindings ->
( TableRef,([(String,Type)]),([LocalIdentifierBindingsUpdate]),TableRef,([(String,[(String,Type)])]),([(String,[(String,Type)])]),([(String,Type)]))
data Inh_TableRef = Inh_TableRef {cat_Inh_TableRef :: Catalog,jlibUpdates_Inh_TableRef :: [LocalIdentifierBindingsUpdate],lib_Inh_TableRef :: LocalIdentifierBindings}
data Syn_TableRef = Syn_TableRef {annotatedTree_Syn_TableRef :: TableRef,idLookups_Syn_TableRef :: [(String,Type)],libUpdates_Syn_TableRef :: [LocalIdentifierBindingsUpdate],originalTree_Syn_TableRef :: TableRef,qidLookups_Syn_TableRef :: [(String,[(String,Type)])],qstarExpansion_Syn_TableRef :: [(String,[(String,Type)])],starExpansion_Syn_TableRef :: [(String,Type)]}
wrap_TableRef :: T_TableRef ->
Inh_TableRef ->
Syn_TableRef
wrap_TableRef sem (Inh_TableRef _lhsIcat _lhsIjlibUpdates _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOidLookups,_lhsOlibUpdates,_lhsOoriginalTree,_lhsOqidLookups,_lhsOqstarExpansion,_lhsOstarExpansion) =
(sem _lhsIcat _lhsIjlibUpdates _lhsIlib )
in (Syn_TableRef _lhsOannotatedTree _lhsOidLookups _lhsOlibUpdates _lhsOoriginalTree _lhsOqidLookups _lhsOqstarExpansion _lhsOstarExpansion ))
sem_TableRef_JoinedTref :: Annotation ->
T_TableRef ->
T_Natural ->
T_JoinType ->
T_TableRef ->
T_OnExpr ->
T_TableAlias ->
T_TableRef
sem_TableRef_JoinedTref ann_ tbl_ nat_ joinType_ tbl1_ onExpr_ alias_ =
(\ _lhsIcat
_lhsIjlibUpdates
_lhsIlib ->
(let _lhsOannotatedTree :: TableRef
_ejoinAttrs :: (Either [TypeError] [(String,Type)])
_idLookups :: ([(String,Type)])
_qidLookups :: ([(String,[(String,Type)])])
_starExpansion :: ([(String,Type)])
_qstarExpansion :: ([(String,[(String,Type)])])
_onExprOlib :: LocalIdentifierBindings
_tblOjlibUpdates :: ([LocalIdentifierBindingsUpdate])
_tbl1OjlibUpdates :: ([LocalIdentifierBindingsUpdate])
_lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_lhsOidLookups :: ([(String,Type)])
_lhsOqidLookups :: ([(String,[(String,Type)])])
_lhsOstarExpansion :: ([(String,Type)])
_lhsOqstarExpansion :: ([(String,[(String,Type)])])
_lhsOoriginalTree :: TableRef
_tblOcat :: Catalog
_tblOlib :: LocalIdentifierBindings
_natOcat :: Catalog
_natOlib :: LocalIdentifierBindings
_joinTypeOcat :: Catalog
_joinTypeOlib :: LocalIdentifierBindings
_tbl1Ocat :: Catalog
_tbl1Olib :: LocalIdentifierBindings
_onExprOcat :: Catalog
_aliasOcat :: Catalog
_aliasOlib :: LocalIdentifierBindings
_tblIannotatedTree :: TableRef
_tblIidLookups :: ([(String,Type)])
_tblIlibUpdates :: ([LocalIdentifierBindingsUpdate])
_tblIoriginalTree :: TableRef
_tblIqidLookups :: ([(String,[(String,Type)])])
_tblIqstarExpansion :: ([(String,[(String,Type)])])
_tblIstarExpansion :: ([(String,Type)])
_natIannotatedTree :: Natural
_natIoriginalTree :: Natural
_joinTypeIannotatedTree :: JoinType
_joinTypeIoriginalTree :: JoinType
_tbl1IannotatedTree :: TableRef
_tbl1IidLookups :: ([(String,Type)])
_tbl1IlibUpdates :: ([LocalIdentifierBindingsUpdate])
_tbl1IoriginalTree :: TableRef
_tbl1IqidLookups :: ([(String,[(String,Type)])])
_tbl1IqstarExpansion :: ([(String,[(String,Type)])])
_tbl1IstarExpansion :: ([(String,Type)])
_onExprIannotatedTree :: OnExpr
_onExprIoriginalTree :: OnExpr
_aliasIannotatedTree :: TableAlias
_aliasIoriginalTree :: TableAlias
-- "./TypeChecking/TableRefs.ag"(line 33, column 9)
_lhsOannotatedTree =
{-# LINE 33 "./TypeChecking/TableRefs.ag" #-}
updateAnnotation (map TypeErrorA _errs ++) _backTree
{-# LINE 14028 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 75, column 9)
_libUpdates =
{-# LINE 75 "./TypeChecking/TableRefs.ag" #-}
if null _errs
then [LibStackIDs $ ("", _idLookups ): _qidLookups
,LibSetStarExpansion $ ("", _starExpansion ): _qstarExpansion ]
else []
{-# LINE 14036 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 135, column 9)
_errs =
{-# LINE 135 "./TypeChecking/TableRefs.ag" #-}
fromLeft [] _ejoinAttrs
{-# LINE 14041 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 136, column 9)
_removeJoinAttrs =
{-# LINE 136 "./TypeChecking/TableRefs.ag" #-}
filter (\(n,_) -> n `notElem` _joinNames )
{-# LINE 14046 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 146, column 9)
_ejoinAttrs =
{-# LINE 146 "./TypeChecking/TableRefs.ag" #-}
do
let jns = case (_natIannotatedTree, _onExprIoriginalTree) of
(Natural, _) -> commonFieldNames
(_,Just (JoinUsing _ s)) -> s
_ -> []
tjtsm = map (flip lookup _tblIidLookups) jns
t1jtsm = map (flip lookup _tbl1IidLookups) jns
errorWhen (not $ null $ filter (==Nothing) $ tjtsm ++ t1jtsm)
[MissingJoinAttribute]
let tjts = catMaybes tjtsm
t1jts = catMaybes t1jtsm
resolvedTypes :: [Either [TypeError] Type]
resolvedTypes = map (\(a,b) -> resolveResultSetType _lhsIcat [a,b]) $ zip tjts t1jts
liftErrors $ concat $ lefts resolvedTypes
return $ zip jns $ rights resolvedTypes
where
commonFieldNames = intersect (f _tblIstarExpansion) (f _tbl1IstarExpansion)
where f = map fst
{-# LINE 14068 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 170, column 9)
_joinNames =
{-# LINE 170 "./TypeChecking/TableRefs.ag" #-}
map fst _joinAttrs
{-# LINE 14073 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 171, column 9)
_joinAttrs =
{-# LINE 171 "./TypeChecking/TableRefs.ag" #-}
fromRight [] _ejoinAttrs
{-# LINE 14078 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 176, column 9)
_idLookups =
{-# LINE 176 "./TypeChecking/TableRefs.ag" #-}
_joinAttrs ++
_removeJoinAttrs _tblIidLookups ++
_removeJoinAttrs _tbl1IidLookups
{-# LINE 14085 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 179, column 9)
_qidLookups =
{-# LINE 179 "./TypeChecking/TableRefs.ag" #-}
_tblIqidLookups ++ _tbl1IqidLookups
{-# LINE 14090 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 180, column 9)
_starExpansion =
{-# LINE 180 "./TypeChecking/TableRefs.ag" #-}
_joinAttrs ++
_removeJoinAttrs _tblIstarExpansion ++
_removeJoinAttrs _tbl1IstarExpansion
{-# LINE 14097 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 183, column 9)
_qstarExpansion =
{-# LINE 183 "./TypeChecking/TableRefs.ag" #-}
_tblIqstarExpansion ++ _tbl1IqstarExpansion
{-# LINE 14102 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 187, column 9)
_newLib =
{-# LINE 187 "./TypeChecking/TableRefs.ag" #-}
case updateBindings _lhsIlib _lhsIcat (_libUpdates ++ _lhsIjlibUpdates) of
Left x -> error $ show x
Right e -> e
{-# LINE 14109 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 190, column 9)
_onExprOlib =
{-# LINE 190 "./TypeChecking/TableRefs.ag" #-}
_newLib
{-# LINE 14114 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 192, column 9)
_tblOjlibUpdates =
{-# LINE 192 "./TypeChecking/TableRefs.ag" #-}
_libUpdates
{-# LINE 14119 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 193, column 9)
_tbl1OjlibUpdates =
{-# LINE 193 "./TypeChecking/TableRefs.ag" #-}
_libUpdates
{-# LINE 14124 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 248, column 9)
_lhsOlibUpdates =
{-# LINE 248 "./TypeChecking/TableRefs.ag" #-}
_libUpdates
{-# LINE 14129 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 249, column 9)
_lhsOidLookups =
{-# LINE 249 "./TypeChecking/TableRefs.ag" #-}
_idLookups
{-# LINE 14134 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 250, column 9)
_lhsOqidLookups =
{-# LINE 250 "./TypeChecking/TableRefs.ag" #-}
_qidLookups
{-# LINE 14139 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 251, column 9)
_lhsOstarExpansion =
{-# LINE 251 "./TypeChecking/TableRefs.ag" #-}
_starExpansion
{-# LINE 14144 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 252, column 9)
_lhsOqstarExpansion =
{-# LINE 252 "./TypeChecking/TableRefs.ag" #-}
_qstarExpansion
{-# LINE 14149 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 264, column 9)
_backTree =
{-# LINE 264 "./TypeChecking/TableRefs.ag" #-}
JoinedTref ann_
_tblIannotatedTree
_natIannotatedTree
_joinTypeIannotatedTree
_tbl1IannotatedTree
_onExprIannotatedTree
_aliasIannotatedTree
{-# LINE 14160 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
JoinedTref ann_ _tblIannotatedTree _natIannotatedTree _joinTypeIannotatedTree _tbl1IannotatedTree _onExprIannotatedTree _aliasIannotatedTree
{-# LINE 14165 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
JoinedTref ann_ _tblIoriginalTree _natIoriginalTree _joinTypeIoriginalTree _tbl1IoriginalTree _onExprIoriginalTree _aliasIoriginalTree
{-# LINE 14170 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 14175 "AstInternal.hs" #-}
-- copy rule (down)
_tblOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 14180 "AstInternal.hs" #-}
-- copy rule (down)
_tblOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 14185 "AstInternal.hs" #-}
-- copy rule (down)
_natOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 14190 "AstInternal.hs" #-}
-- copy rule (down)
_natOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 14195 "AstInternal.hs" #-}
-- copy rule (down)
_joinTypeOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 14200 "AstInternal.hs" #-}
-- copy rule (down)
_joinTypeOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 14205 "AstInternal.hs" #-}
-- copy rule (down)
_tbl1Ocat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 14210 "AstInternal.hs" #-}
-- copy rule (down)
_tbl1Olib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 14215 "AstInternal.hs" #-}
-- copy rule (down)
_onExprOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 14220 "AstInternal.hs" #-}
-- copy rule (down)
_aliasOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 14225 "AstInternal.hs" #-}
-- copy rule (down)
_aliasOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 14230 "AstInternal.hs" #-}
( _tblIannotatedTree,_tblIidLookups,_tblIlibUpdates,_tblIoriginalTree,_tblIqidLookups,_tblIqstarExpansion,_tblIstarExpansion) =
(tbl_ _tblOcat _tblOjlibUpdates _tblOlib )
( _natIannotatedTree,_natIoriginalTree) =
(nat_ _natOcat _natOlib )
( _joinTypeIannotatedTree,_joinTypeIoriginalTree) =
(joinType_ _joinTypeOcat _joinTypeOlib )
( _tbl1IannotatedTree,_tbl1IidLookups,_tbl1IlibUpdates,_tbl1IoriginalTree,_tbl1IqidLookups,_tbl1IqstarExpansion,_tbl1IstarExpansion) =
(tbl1_ _tbl1Ocat _tbl1OjlibUpdates _tbl1Olib )
( _onExprIannotatedTree,_onExprIoriginalTree) =
(onExpr_ _onExprOcat _onExprOlib )
( _aliasIannotatedTree,_aliasIoriginalTree) =
(alias_ _aliasOcat _aliasOlib )
in ( _lhsOannotatedTree,_lhsOidLookups,_lhsOlibUpdates,_lhsOoriginalTree,_lhsOqidLookups,_lhsOqstarExpansion,_lhsOstarExpansion)))
sem_TableRef_SubTref :: Annotation ->
T_SelectExpression ->
T_TableAlias ->
T_TableRef
sem_TableRef_SubTref ann_ sel_ alias_ =
(\ _lhsIcat
_lhsIjlibUpdates
_lhsIlib ->
(let _lhsOannotatedTree :: TableRef
_selectAttrs :: (Either [TypeError] [(String,Type)])
_idLookups :: ([(String,Type)])
_qidLookups :: ([(String,[(String,Type)])])
_starExpansion :: ([(String,Type)])
_qstarExpansion :: ([(String,[(String,Type)])])
_lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_lhsOidLookups :: ([(String,Type)])
_lhsOqidLookups :: ([(String,[(String,Type)])])
_lhsOstarExpansion :: ([(String,Type)])
_lhsOqstarExpansion :: ([(String,[(String,Type)])])
_lhsOoriginalTree :: TableRef
_selOcat :: Catalog
_selOlib :: LocalIdentifierBindings
_aliasOcat :: Catalog
_aliasOlib :: LocalIdentifierBindings
_selIannotatedTree :: SelectExpression
_selIlibUpdates :: ([LocalIdentifierBindingsUpdate])
_selIoriginalTree :: SelectExpression
_aliasIannotatedTree :: TableAlias
_aliasIoriginalTree :: TableAlias
-- "./TypeChecking/TableRefs.ag"(line 33, column 9)
_lhsOannotatedTree =
{-# LINE 33 "./TypeChecking/TableRefs.ag" #-}
updateAnnotation (map TypeErrorA _errs ++) _backTree
{-# LINE 14277 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 75, column 9)
_libUpdates =
{-# LINE 75 "./TypeChecking/TableRefs.ag" #-}
if null _errs
then [LibStackIDs $ ("", _idLookups ): _qidLookups
,LibSetStarExpansion $ ("", _starExpansion ): _qstarExpansion ]
else []
{-# LINE 14285 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 92, column 9)
_errs =
{-# LINE 92 "./TypeChecking/TableRefs.ag" #-}
case _selectAttrs of
Left e -> e
Right _ -> []
{-# LINE 14292 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 96, column 9)
_selectAttrs =
{-# LINE 96 "./TypeChecking/TableRefs.ag" #-}
unwrapSetOfComposite (getTypeAnnotation _selIannotatedTree)
{-# LINE 14297 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 98, column 9)
_idLookups =
{-# LINE 98 "./TypeChecking/TableRefs.ag" #-}
fromRight [] _selectAttrs
{-# LINE 14302 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 99, column 9)
_qidLookups =
{-# LINE 99 "./TypeChecking/TableRefs.ag" #-}
[(getAlias "" _aliasIannotatedTree, _idLookups )]
{-# LINE 14307 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 100, column 9)
_starExpansion =
{-# LINE 100 "./TypeChecking/TableRefs.ag" #-}
_idLookups
{-# LINE 14312 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 101, column 9)
_qstarExpansion =
{-# LINE 101 "./TypeChecking/TableRefs.ag" #-}
_qidLookups
{-# LINE 14317 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 248, column 9)
_lhsOlibUpdates =
{-# LINE 248 "./TypeChecking/TableRefs.ag" #-}
_libUpdates
{-# LINE 14322 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 249, column 9)
_lhsOidLookups =
{-# LINE 249 "./TypeChecking/TableRefs.ag" #-}
_idLookups
{-# LINE 14327 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 250, column 9)
_lhsOqidLookups =
{-# LINE 250 "./TypeChecking/TableRefs.ag" #-}
_qidLookups
{-# LINE 14332 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 251, column 9)
_lhsOstarExpansion =
{-# LINE 251 "./TypeChecking/TableRefs.ag" #-}
_starExpansion
{-# LINE 14337 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 252, column 9)
_lhsOqstarExpansion =
{-# LINE 252 "./TypeChecking/TableRefs.ag" #-}
_qstarExpansion
{-# LINE 14342 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 258, column 9)
_backTree =
{-# LINE 258 "./TypeChecking/TableRefs.ag" #-}
SubTref ann_ _selIannotatedTree _aliasIannotatedTree
{-# LINE 14347 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
SubTref ann_ _selIannotatedTree _aliasIannotatedTree
{-# LINE 14352 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
SubTref ann_ _selIoriginalTree _aliasIoriginalTree
{-# LINE 14357 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 14362 "AstInternal.hs" #-}
-- copy rule (down)
_selOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 14367 "AstInternal.hs" #-}
-- copy rule (down)
_selOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 14372 "AstInternal.hs" #-}
-- copy rule (down)
_aliasOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 14377 "AstInternal.hs" #-}
-- copy rule (down)
_aliasOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 14382 "AstInternal.hs" #-}
( _selIannotatedTree,_selIlibUpdates,_selIoriginalTree) =
(sel_ _selOcat _selOlib )
( _aliasIannotatedTree,_aliasIoriginalTree) =
(alias_ _aliasOcat _aliasOlib )
in ( _lhsOannotatedTree,_lhsOidLookups,_lhsOlibUpdates,_lhsOoriginalTree,_lhsOqidLookups,_lhsOqstarExpansion,_lhsOstarExpansion)))
sem_TableRef_Tref :: Annotation ->
String ->
T_TableAlias ->
T_TableRef
sem_TableRef_Tref ann_ tbl_ alias_ =
(\ _lhsIcat
_lhsIjlibUpdates
_lhsIlib ->
(let _lhsOannotatedTree :: TableRef
_relType :: (Either [TypeError] ([(String, Type)], [(String, Type)]))
_idLookups :: ([(String,Type)])
_qidLookups :: ([(String,[(String,Type)])])
_starExpansion :: ([(String,Type)])
_qstarExpansion :: ([(String,[(String,Type)])])
_lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_lhsOidLookups :: ([(String,Type)])
_lhsOqidLookups :: ([(String,[(String,Type)])])
_lhsOstarExpansion :: ([(String,Type)])
_lhsOqstarExpansion :: ([(String,[(String,Type)])])
_lhsOoriginalTree :: TableRef
_aliasOcat :: Catalog
_aliasOlib :: LocalIdentifierBindings
_aliasIannotatedTree :: TableAlias
_aliasIoriginalTree :: TableAlias
-- "./TypeChecking/TableRefs.ag"(line 33, column 9)
_lhsOannotatedTree =
{-# LINE 33 "./TypeChecking/TableRefs.ag" #-}
updateAnnotation (map TypeErrorA _errs ++) _backTree
{-# LINE 14416 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 75, column 9)
_libUpdates =
{-# LINE 75 "./TypeChecking/TableRefs.ag" #-}
if null _errs
then [LibStackIDs $ ("", _idLookups ): _qidLookups
,LibSetStarExpansion $ ("", _starExpansion ): _qstarExpansion ]
else []
{-# LINE 14424 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 104, column 9)
_errs =
{-# LINE 104 "./TypeChecking/TableRefs.ag" #-}
case _relType of
Left e -> e
Right _ -> []
{-# LINE 14431 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 108, column 9)
_relType =
{-# LINE 108 "./TypeChecking/TableRefs.ag" #-}
catCompositeAttrsPair _lhsIcat [] tbl_
{-# LINE 14436 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 109, column 9)
_relType1 =
{-# LINE 109 "./TypeChecking/TableRefs.ag" #-}
fromRight ([],[]) _relType
{-# LINE 14441 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 110, column 9)
_pAttrs =
{-# LINE 110 "./TypeChecking/TableRefs.ag" #-}
fst _relType1
{-# LINE 14446 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 111, column 9)
_sAttrs =
{-# LINE 111 "./TypeChecking/TableRefs.ag" #-}
snd _relType1
{-# LINE 14451 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 113, column 9)
_idLookups =
{-# LINE 113 "./TypeChecking/TableRefs.ag" #-}
_pAttrs ++ _sAttrs
{-# LINE 14456 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 114, column 9)
_alias =
{-# LINE 114 "./TypeChecking/TableRefs.ag" #-}
getAlias tbl_ _aliasIannotatedTree
{-# LINE 14461 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 115, column 9)
_qidLookups =
{-# LINE 115 "./TypeChecking/TableRefs.ag" #-}
[(_alias , _idLookups )]
{-# LINE 14466 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 116, column 9)
_starExpansion =
{-# LINE 116 "./TypeChecking/TableRefs.ag" #-}
_pAttrs
{-# LINE 14471 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 117, column 9)
_qstarExpansion =
{-# LINE 117 "./TypeChecking/TableRefs.ag" #-}
[(_alias , _pAttrs )]
{-# LINE 14476 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 248, column 9)
_lhsOlibUpdates =
{-# LINE 248 "./TypeChecking/TableRefs.ag" #-}
_libUpdates
{-# LINE 14481 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 249, column 9)
_lhsOidLookups =
{-# LINE 249 "./TypeChecking/TableRefs.ag" #-}
_idLookups
{-# LINE 14486 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 250, column 9)
_lhsOqidLookups =
{-# LINE 250 "./TypeChecking/TableRefs.ag" #-}
_qidLookups
{-# LINE 14491 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 251, column 9)
_lhsOstarExpansion =
{-# LINE 251 "./TypeChecking/TableRefs.ag" #-}
_starExpansion
{-# LINE 14496 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 252, column 9)
_lhsOqstarExpansion =
{-# LINE 252 "./TypeChecking/TableRefs.ag" #-}
_qstarExpansion
{-# LINE 14501 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 260, column 9)
_backTree =
{-# LINE 260 "./TypeChecking/TableRefs.ag" #-}
Tref ann_ tbl_ _aliasIannotatedTree
{-# LINE 14506 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
Tref ann_ tbl_ _aliasIannotatedTree
{-# LINE 14511 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
Tref ann_ tbl_ _aliasIoriginalTree
{-# LINE 14516 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 14521 "AstInternal.hs" #-}
-- copy rule (down)
_aliasOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 14526 "AstInternal.hs" #-}
-- copy rule (down)
_aliasOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 14531 "AstInternal.hs" #-}
( _aliasIannotatedTree,_aliasIoriginalTree) =
(alias_ _aliasOcat _aliasOlib )
in ( _lhsOannotatedTree,_lhsOidLookups,_lhsOlibUpdates,_lhsOoriginalTree,_lhsOqidLookups,_lhsOqstarExpansion,_lhsOstarExpansion)))
sem_TableRef_TrefFun :: Annotation ->
T_Expression ->
T_TableAlias ->
T_TableRef
sem_TableRef_TrefFun ann_ fn_ alias_ =
(\ _lhsIcat
_lhsIjlibUpdates
_lhsIlib ->
(let _lhsOannotatedTree :: TableRef
_eqfunIdens :: (Either [TypeError] (String,[(String,Type)]))
_idLookups :: ([(String,Type)])
_qidLookups :: ([(String,[(String,Type)])])
_starExpansion :: ([(String,Type)])
_qstarExpansion :: ([(String,[(String,Type)])])
_lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_lhsOidLookups :: ([(String,Type)])
_lhsOqidLookups :: ([(String,[(String,Type)])])
_lhsOstarExpansion :: ([(String,Type)])
_lhsOqstarExpansion :: ([(String,[(String,Type)])])
_lhsOoriginalTree :: TableRef
_fnOcat :: Catalog
_fnOlib :: LocalIdentifierBindings
_aliasOcat :: Catalog
_aliasOlib :: LocalIdentifierBindings
_fnIannotatedTree :: Expression
_fnIliftedColumnName :: String
_fnIoriginalTree :: Expression
_aliasIannotatedTree :: TableAlias
_aliasIoriginalTree :: TableAlias
-- "./TypeChecking/TableRefs.ag"(line 33, column 9)
_lhsOannotatedTree =
{-# LINE 33 "./TypeChecking/TableRefs.ag" #-}
updateAnnotation (map TypeErrorA _errs ++) _backTree
{-# LINE 14568 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 75, column 9)
_libUpdates =
{-# LINE 75 "./TypeChecking/TableRefs.ag" #-}
if null _errs
then [LibStackIDs $ ("", _idLookups ): _qidLookups
,LibSetStarExpansion $ ("", _starExpansion ): _qstarExpansion ]
else []
{-# LINE 14576 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 120, column 9)
_errs =
{-# LINE 120 "./TypeChecking/TableRefs.ag" #-}
case _eqfunIdens of
Left e -> e
Right _ -> []
{-# LINE 14583 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 124, column 9)
_eqfunIdens =
{-# LINE 124 "./TypeChecking/TableRefs.ag" #-}
funIdens _lhsIcat _alias _fnIannotatedTree
{-# LINE 14588 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 125, column 9)
_qfunIdens =
{-# LINE 125 "./TypeChecking/TableRefs.ag" #-}
fromRight ("",[]) _eqfunIdens
{-# LINE 14593 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 126, column 9)
_alias2 =
{-# LINE 126 "./TypeChecking/TableRefs.ag" #-}
fst _qfunIdens
{-# LINE 14598 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 127, column 9)
_funIdens =
{-# LINE 127 "./TypeChecking/TableRefs.ag" #-}
snd _qfunIdens
{-# LINE 14603 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 128, column 9)
_alias =
{-# LINE 128 "./TypeChecking/TableRefs.ag" #-}
getAlias "" _aliasIannotatedTree
{-# LINE 14608 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 130, column 9)
_idLookups =
{-# LINE 130 "./TypeChecking/TableRefs.ag" #-}
_funIdens
{-# LINE 14613 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 131, column 9)
_qidLookups =
{-# LINE 131 "./TypeChecking/TableRefs.ag" #-}
[(_alias2, _idLookups )]
{-# LINE 14618 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 132, column 9)
_starExpansion =
{-# LINE 132 "./TypeChecking/TableRefs.ag" #-}
_idLookups
{-# LINE 14623 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 133, column 9)
_qstarExpansion =
{-# LINE 133 "./TypeChecking/TableRefs.ag" #-}
_qidLookups
{-# LINE 14628 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 248, column 9)
_lhsOlibUpdates =
{-# LINE 248 "./TypeChecking/TableRefs.ag" #-}
_libUpdates
{-# LINE 14633 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 249, column 9)
_lhsOidLookups =
{-# LINE 249 "./TypeChecking/TableRefs.ag" #-}
_idLookups
{-# LINE 14638 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 250, column 9)
_lhsOqidLookups =
{-# LINE 250 "./TypeChecking/TableRefs.ag" #-}
_qidLookups
{-# LINE 14643 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 251, column 9)
_lhsOstarExpansion =
{-# LINE 251 "./TypeChecking/TableRefs.ag" #-}
_starExpansion
{-# LINE 14648 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 252, column 9)
_lhsOqstarExpansion =
{-# LINE 252 "./TypeChecking/TableRefs.ag" #-}
_qstarExpansion
{-# LINE 14653 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 262, column 9)
_backTree =
{-# LINE 262 "./TypeChecking/TableRefs.ag" #-}
TrefFun ann_ _fnIannotatedTree _aliasIannotatedTree
{-# LINE 14658 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
TrefFun ann_ _fnIannotatedTree _aliasIannotatedTree
{-# LINE 14663 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
TrefFun ann_ _fnIoriginalTree _aliasIoriginalTree
{-# LINE 14668 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 14673 "AstInternal.hs" #-}
-- copy rule (down)
_fnOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 14678 "AstInternal.hs" #-}
-- copy rule (down)
_fnOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 14683 "AstInternal.hs" #-}
-- copy rule (down)
_aliasOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 14688 "AstInternal.hs" #-}
-- copy rule (down)
_aliasOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 14693 "AstInternal.hs" #-}
( _fnIannotatedTree,_fnIliftedColumnName,_fnIoriginalTree) =
(fn_ _fnOcat _fnOlib )
( _aliasIannotatedTree,_aliasIoriginalTree) =
(alias_ _aliasOcat _aliasOlib )
in ( _lhsOannotatedTree,_lhsOidLookups,_lhsOlibUpdates,_lhsOoriginalTree,_lhsOqidLookups,_lhsOqstarExpansion,_lhsOstarExpansion)))
-- TableRefList ------------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
libUpdates : [LocalIdentifierBindingsUpdate]
originalTree : SELF
alternatives:
alternative Cons:
child hd : TableRef
child tl : TableRefList
visit 0:
local annotatedTree : _
local originalTree : _
alternative Nil:
visit 0:
local annotatedTree : _
local originalTree : _
-}
type TableRefList = [(TableRef)]
-- cata
sem_TableRefList :: TableRefList ->
T_TableRefList
sem_TableRefList list =
(Prelude.foldr sem_TableRefList_Cons sem_TableRefList_Nil (Prelude.map sem_TableRef list) )
-- semantic domain
type T_TableRefList = Catalog ->
LocalIdentifierBindings ->
( TableRefList,([LocalIdentifierBindingsUpdate]),TableRefList)
data Inh_TableRefList = Inh_TableRefList {cat_Inh_TableRefList :: Catalog,lib_Inh_TableRefList :: LocalIdentifierBindings}
data Syn_TableRefList = Syn_TableRefList {annotatedTree_Syn_TableRefList :: TableRefList,libUpdates_Syn_TableRefList :: [LocalIdentifierBindingsUpdate],originalTree_Syn_TableRefList :: TableRefList}
wrap_TableRefList :: T_TableRefList ->
Inh_TableRefList ->
Syn_TableRefList
wrap_TableRefList sem (Inh_TableRefList _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOlibUpdates,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_TableRefList _lhsOannotatedTree _lhsOlibUpdates _lhsOoriginalTree ))
sem_TableRefList_Cons :: T_TableRef ->
T_TableRefList ->
T_TableRefList
sem_TableRefList_Cons hd_ tl_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_hdOjlibUpdates :: ([LocalIdentifierBindingsUpdate])
_lhsOannotatedTree :: TableRefList
_lhsOoriginalTree :: TableRefList
_hdOcat :: Catalog
_hdOlib :: LocalIdentifierBindings
_tlOcat :: Catalog
_tlOlib :: LocalIdentifierBindings
_hdIannotatedTree :: TableRef
_hdIidLookups :: ([(String,Type)])
_hdIlibUpdates :: ([LocalIdentifierBindingsUpdate])
_hdIoriginalTree :: TableRef
_hdIqidLookups :: ([(String,[(String,Type)])])
_hdIqstarExpansion :: ([(String,[(String,Type)])])
_hdIstarExpansion :: ([(String,Type)])
_tlIannotatedTree :: TableRefList
_tlIlibUpdates :: ([LocalIdentifierBindingsUpdate])
_tlIoriginalTree :: TableRefList
-- "./TypeChecking/TableRefs.ag"(line 40, column 9)
_lhsOlibUpdates =
{-# LINE 40 "./TypeChecking/TableRefs.ag" #-}
_hdIlibUpdates
{-# LINE 14768 "AstInternal.hs" #-}
-- "./TypeChecking/TableRefs.ag"(line 197, column 12)
_hdOjlibUpdates =
{-# LINE 197 "./TypeChecking/TableRefs.ag" #-}
[]
{-# LINE 14773 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
(:) _hdIannotatedTree _tlIannotatedTree
{-# LINE 14778 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
(:) _hdIoriginalTree _tlIoriginalTree
{-# LINE 14783 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 14788 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 14793 "AstInternal.hs" #-}
-- copy rule (down)
_hdOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 14798 "AstInternal.hs" #-}
-- copy rule (down)
_hdOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 14803 "AstInternal.hs" #-}
-- copy rule (down)
_tlOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 14808 "AstInternal.hs" #-}
-- copy rule (down)
_tlOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 14813 "AstInternal.hs" #-}
( _hdIannotatedTree,_hdIidLookups,_hdIlibUpdates,_hdIoriginalTree,_hdIqidLookups,_hdIqstarExpansion,_hdIstarExpansion) =
(hd_ _hdOcat _hdOjlibUpdates _hdOlib )
( _tlIannotatedTree,_tlIlibUpdates,_tlIoriginalTree) =
(tl_ _tlOcat _tlOlib )
in ( _lhsOannotatedTree,_lhsOlibUpdates,_lhsOoriginalTree)))
sem_TableRefList_Nil :: T_TableRefList
sem_TableRefList_Nil =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate])
_lhsOannotatedTree :: TableRefList
_lhsOoriginalTree :: TableRefList
-- "./TypeChecking/TableRefs.ag"(line 38, column 9)
_lhsOlibUpdates =
{-# LINE 38 "./TypeChecking/TableRefs.ag" #-}
[]
{-# LINE 14830 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
[]
{-# LINE 14835 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
[]
{-# LINE 14840 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 14845 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 14850 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOlibUpdates,_lhsOoriginalTree)))
-- TriggerEvent ------------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
originalTree : SELF
alternatives:
alternative TDelete:
visit 0:
local annotatedTree : _
local originalTree : _
alternative TInsert:
visit 0:
local annotatedTree : _
local originalTree : _
alternative TUpdate:
visit 0:
local annotatedTree : _
local originalTree : _
-}
data TriggerEvent = TDelete
| TInsert
| TUpdate
deriving ( Data,Eq,Show,Typeable)
-- cata
sem_TriggerEvent :: TriggerEvent ->
T_TriggerEvent
sem_TriggerEvent (TDelete ) =
(sem_TriggerEvent_TDelete )
sem_TriggerEvent (TInsert ) =
(sem_TriggerEvent_TInsert )
sem_TriggerEvent (TUpdate ) =
(sem_TriggerEvent_TUpdate )
-- semantic domain
type T_TriggerEvent = Catalog ->
LocalIdentifierBindings ->
( TriggerEvent,TriggerEvent)
data Inh_TriggerEvent = Inh_TriggerEvent {cat_Inh_TriggerEvent :: Catalog,lib_Inh_TriggerEvent :: LocalIdentifierBindings}
data Syn_TriggerEvent = Syn_TriggerEvent {annotatedTree_Syn_TriggerEvent :: TriggerEvent,originalTree_Syn_TriggerEvent :: TriggerEvent}
wrap_TriggerEvent :: T_TriggerEvent ->
Inh_TriggerEvent ->
Syn_TriggerEvent
wrap_TriggerEvent sem (Inh_TriggerEvent _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_TriggerEvent _lhsOannotatedTree _lhsOoriginalTree ))
sem_TriggerEvent_TDelete :: T_TriggerEvent
sem_TriggerEvent_TDelete =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: TriggerEvent
_lhsOoriginalTree :: TriggerEvent
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
TDelete
{-# LINE 14911 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
TDelete
{-# LINE 14916 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 14921 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 14926 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
sem_TriggerEvent_TInsert :: T_TriggerEvent
sem_TriggerEvent_TInsert =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: TriggerEvent
_lhsOoriginalTree :: TriggerEvent
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
TInsert
{-# LINE 14938 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
TInsert
{-# LINE 14943 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 14948 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 14953 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
sem_TriggerEvent_TUpdate :: T_TriggerEvent
sem_TriggerEvent_TUpdate =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: TriggerEvent
_lhsOoriginalTree :: TriggerEvent
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
TUpdate
{-# LINE 14965 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
TUpdate
{-# LINE 14970 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 14975 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 14980 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
-- TriggerFire -------------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
originalTree : SELF
alternatives:
alternative EachRow:
visit 0:
local annotatedTree : _
local originalTree : _
alternative EachStatement:
visit 0:
local annotatedTree : _
local originalTree : _
-}
data TriggerFire = EachRow
| EachStatement
deriving ( Data,Eq,Show,Typeable)
-- cata
sem_TriggerFire :: TriggerFire ->
T_TriggerFire
sem_TriggerFire (EachRow ) =
(sem_TriggerFire_EachRow )
sem_TriggerFire (EachStatement ) =
(sem_TriggerFire_EachStatement )
-- semantic domain
type T_TriggerFire = Catalog ->
LocalIdentifierBindings ->
( TriggerFire,TriggerFire)
data Inh_TriggerFire = Inh_TriggerFire {cat_Inh_TriggerFire :: Catalog,lib_Inh_TriggerFire :: LocalIdentifierBindings}
data Syn_TriggerFire = Syn_TriggerFire {annotatedTree_Syn_TriggerFire :: TriggerFire,originalTree_Syn_TriggerFire :: TriggerFire}
wrap_TriggerFire :: T_TriggerFire ->
Inh_TriggerFire ->
Syn_TriggerFire
wrap_TriggerFire sem (Inh_TriggerFire _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_TriggerFire _lhsOannotatedTree _lhsOoriginalTree ))
sem_TriggerFire_EachRow :: T_TriggerFire
sem_TriggerFire_EachRow =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: TriggerFire
_lhsOoriginalTree :: TriggerFire
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
EachRow
{-# LINE 15034 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
EachRow
{-# LINE 15039 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 15044 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 15049 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
sem_TriggerFire_EachStatement :: T_TriggerFire
sem_TriggerFire_EachStatement =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: TriggerFire
_lhsOoriginalTree :: TriggerFire
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
EachStatement
{-# LINE 15061 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
EachStatement
{-# LINE 15066 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 15071 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 15076 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
-- TriggerWhen -------------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
originalTree : SELF
alternatives:
alternative TriggerAfter:
visit 0:
local annotatedTree : _
local originalTree : _
alternative TriggerBefore:
visit 0:
local annotatedTree : _
local originalTree : _
-}
data TriggerWhen = TriggerAfter
| TriggerBefore
deriving ( Data,Eq,Show,Typeable)
-- cata
sem_TriggerWhen :: TriggerWhen ->
T_TriggerWhen
sem_TriggerWhen (TriggerAfter ) =
(sem_TriggerWhen_TriggerAfter )
sem_TriggerWhen (TriggerBefore ) =
(sem_TriggerWhen_TriggerBefore )
-- semantic domain
type T_TriggerWhen = Catalog ->
LocalIdentifierBindings ->
( TriggerWhen,TriggerWhen)
data Inh_TriggerWhen = Inh_TriggerWhen {cat_Inh_TriggerWhen :: Catalog,lib_Inh_TriggerWhen :: LocalIdentifierBindings}
data Syn_TriggerWhen = Syn_TriggerWhen {annotatedTree_Syn_TriggerWhen :: TriggerWhen,originalTree_Syn_TriggerWhen :: TriggerWhen}
wrap_TriggerWhen :: T_TriggerWhen ->
Inh_TriggerWhen ->
Syn_TriggerWhen
wrap_TriggerWhen sem (Inh_TriggerWhen _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_TriggerWhen _lhsOannotatedTree _lhsOoriginalTree ))
sem_TriggerWhen_TriggerAfter :: T_TriggerWhen
sem_TriggerWhen_TriggerAfter =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: TriggerWhen
_lhsOoriginalTree :: TriggerWhen
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
TriggerAfter
{-# LINE 15130 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
TriggerAfter
{-# LINE 15135 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 15140 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 15145 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
sem_TriggerWhen_TriggerBefore :: T_TriggerWhen
sem_TriggerWhen_TriggerBefore =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: TriggerWhen
_lhsOoriginalTree :: TriggerWhen
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
TriggerBefore
{-# LINE 15157 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
TriggerBefore
{-# LINE 15162 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 15167 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 15172 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
-- TypeAttributeDef --------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
attrName : String
namedType : Type
originalTree : SELF
alternatives:
alternative TypeAttDef:
child ann : {Annotation}
child name : {String}
child typ : TypeName
visit 0:
local annotatedTree : _
local originalTree : _
-}
data TypeAttributeDef = TypeAttDef (Annotation) (String) (TypeName)
deriving ( Data,Eq,Show,Typeable)
-- cata
sem_TypeAttributeDef :: TypeAttributeDef ->
T_TypeAttributeDef
sem_TypeAttributeDef (TypeAttDef _ann _name _typ ) =
(sem_TypeAttributeDef_TypeAttDef _ann _name (sem_TypeName _typ ) )
-- semantic domain
type T_TypeAttributeDef = Catalog ->
LocalIdentifierBindings ->
( TypeAttributeDef,String,Type,TypeAttributeDef)
data Inh_TypeAttributeDef = Inh_TypeAttributeDef {cat_Inh_TypeAttributeDef :: Catalog,lib_Inh_TypeAttributeDef :: LocalIdentifierBindings}
data Syn_TypeAttributeDef = Syn_TypeAttributeDef {annotatedTree_Syn_TypeAttributeDef :: TypeAttributeDef,attrName_Syn_TypeAttributeDef :: String,namedType_Syn_TypeAttributeDef :: Type,originalTree_Syn_TypeAttributeDef :: TypeAttributeDef}
wrap_TypeAttributeDef :: T_TypeAttributeDef ->
Inh_TypeAttributeDef ->
Syn_TypeAttributeDef
wrap_TypeAttributeDef sem (Inh_TypeAttributeDef _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOattrName,_lhsOnamedType,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_TypeAttributeDef _lhsOannotatedTree _lhsOattrName _lhsOnamedType _lhsOoriginalTree ))
sem_TypeAttributeDef_TypeAttDef :: Annotation ->
String ->
T_TypeName ->
T_TypeAttributeDef
sem_TypeAttributeDef_TypeAttDef ann_ name_ typ_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOattrName :: String
_lhsOnamedType :: Type
_lhsOannotatedTree :: TypeAttributeDef
_lhsOoriginalTree :: TypeAttributeDef
_typOcat :: Catalog
_typOlib :: LocalIdentifierBindings
_typIannotatedTree :: TypeName
_typInamedType :: Type
_typIoriginalTree :: TypeName
-- "./TypeChecking/MiscCreates.ag"(line 40, column 9)
_lhsOattrName =
{-# LINE 40 "./TypeChecking/MiscCreates.ag" #-}
name_
{-# LINE 15234 "AstInternal.hs" #-}
-- "./TypeChecking/MiscCreates.ag"(line 41, column 9)
_lhsOnamedType =
{-# LINE 41 "./TypeChecking/MiscCreates.ag" #-}
_typInamedType
{-# LINE 15239 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
TypeAttDef ann_ name_ _typIannotatedTree
{-# LINE 15244 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
TypeAttDef ann_ name_ _typIoriginalTree
{-# LINE 15249 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 15254 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 15259 "AstInternal.hs" #-}
-- copy rule (down)
_typOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 15264 "AstInternal.hs" #-}
-- copy rule (down)
_typOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 15269 "AstInternal.hs" #-}
( _typIannotatedTree,_typInamedType,_typIoriginalTree) =
(typ_ _typOcat _typOlib )
in ( _lhsOannotatedTree,_lhsOattrName,_lhsOnamedType,_lhsOoriginalTree)))
-- TypeAttributeDefList ----------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
attrs : [(String, Type)]
originalTree : SELF
alternatives:
alternative Cons:
child hd : TypeAttributeDef
child tl : TypeAttributeDefList
visit 0:
local annotatedTree : _
local originalTree : _
alternative Nil:
visit 0:
local annotatedTree : _
local originalTree : _
-}
type TypeAttributeDefList = [(TypeAttributeDef)]
-- cata
sem_TypeAttributeDefList :: TypeAttributeDefList ->
T_TypeAttributeDefList
sem_TypeAttributeDefList list =
(Prelude.foldr sem_TypeAttributeDefList_Cons sem_TypeAttributeDefList_Nil (Prelude.map sem_TypeAttributeDef list) )
-- semantic domain
type T_TypeAttributeDefList = Catalog ->
LocalIdentifierBindings ->
( TypeAttributeDefList,([(String, Type)]),TypeAttributeDefList)
data Inh_TypeAttributeDefList = Inh_TypeAttributeDefList {cat_Inh_TypeAttributeDefList :: Catalog,lib_Inh_TypeAttributeDefList :: LocalIdentifierBindings}
data Syn_TypeAttributeDefList = Syn_TypeAttributeDefList {annotatedTree_Syn_TypeAttributeDefList :: TypeAttributeDefList,attrs_Syn_TypeAttributeDefList :: [(String, Type)],originalTree_Syn_TypeAttributeDefList :: TypeAttributeDefList}
wrap_TypeAttributeDefList :: T_TypeAttributeDefList ->
Inh_TypeAttributeDefList ->
Syn_TypeAttributeDefList
wrap_TypeAttributeDefList sem (Inh_TypeAttributeDefList _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOattrs,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_TypeAttributeDefList _lhsOannotatedTree _lhsOattrs _lhsOoriginalTree ))
sem_TypeAttributeDefList_Cons :: T_TypeAttributeDef ->
T_TypeAttributeDefList ->
T_TypeAttributeDefList
sem_TypeAttributeDefList_Cons hd_ tl_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOattrs :: ([(String, Type)])
_lhsOannotatedTree :: TypeAttributeDefList
_lhsOoriginalTree :: TypeAttributeDefList
_hdOcat :: Catalog
_hdOlib :: LocalIdentifierBindings
_tlOcat :: Catalog
_tlOlib :: LocalIdentifierBindings
_hdIannotatedTree :: TypeAttributeDef
_hdIattrName :: String
_hdInamedType :: Type
_hdIoriginalTree :: TypeAttributeDef
_tlIannotatedTree :: TypeAttributeDefList
_tlIattrs :: ([(String, Type)])
_tlIoriginalTree :: TypeAttributeDefList
-- "./TypeChecking/MiscCreates.ag"(line 46, column 12)
_lhsOattrs =
{-# LINE 46 "./TypeChecking/MiscCreates.ag" #-}
(_hdIattrName, _hdInamedType) : _tlIattrs
{-# LINE 15338 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
(:) _hdIannotatedTree _tlIannotatedTree
{-# LINE 15343 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
(:) _hdIoriginalTree _tlIoriginalTree
{-# LINE 15348 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 15353 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 15358 "AstInternal.hs" #-}
-- copy rule (down)
_hdOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 15363 "AstInternal.hs" #-}
-- copy rule (down)
_hdOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 15368 "AstInternal.hs" #-}
-- copy rule (down)
_tlOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 15373 "AstInternal.hs" #-}
-- copy rule (down)
_tlOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 15378 "AstInternal.hs" #-}
( _hdIannotatedTree,_hdIattrName,_hdInamedType,_hdIoriginalTree) =
(hd_ _hdOcat _hdOlib )
( _tlIannotatedTree,_tlIattrs,_tlIoriginalTree) =
(tl_ _tlOcat _tlOlib )
in ( _lhsOannotatedTree,_lhsOattrs,_lhsOoriginalTree)))
sem_TypeAttributeDefList_Nil :: T_TypeAttributeDefList
sem_TypeAttributeDefList_Nil =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOattrs :: ([(String, Type)])
_lhsOannotatedTree :: TypeAttributeDefList
_lhsOoriginalTree :: TypeAttributeDefList
-- "./TypeChecking/MiscCreates.ag"(line 47, column 11)
_lhsOattrs =
{-# LINE 47 "./TypeChecking/MiscCreates.ag" #-}
[]
{-# LINE 15395 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
[]
{-# LINE 15400 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
[]
{-# LINE 15405 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 15410 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 15415 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOattrs,_lhsOoriginalTree)))
-- TypeName ----------------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
namedType : Type
originalTree : SELF
alternatives:
alternative ArrayTypeName:
child ann : {Annotation}
child typ : TypeName
visit 0:
local tpe : _
local backTree : _
local annotatedTree : _
local originalTree : _
alternative PrecTypeName:
child ann : {Annotation}
child tn : {String}
child prec : {Integer}
visit 0:
local tpe : _
local backTree : _
local annotatedTree : _
local originalTree : _
alternative SetOfTypeName:
child ann : {Annotation}
child typ : TypeName
visit 0:
local tpe : _
local backTree : _
local annotatedTree : _
local originalTree : _
alternative SimpleTypeName:
child ann : {Annotation}
child tn : {String}
visit 0:
local tpe : _
local backTree : _
local annotatedTree : _
local originalTree : _
-}
data TypeName = ArrayTypeName (Annotation) (TypeName)
| PrecTypeName (Annotation) (String) (Integer)
| SetOfTypeName (Annotation) (TypeName)
| SimpleTypeName (Annotation) (String)
deriving ( Data,Eq,Show,Typeable)
-- cata
sem_TypeName :: TypeName ->
T_TypeName
sem_TypeName (ArrayTypeName _ann _typ ) =
(sem_TypeName_ArrayTypeName _ann (sem_TypeName _typ ) )
sem_TypeName (PrecTypeName _ann _tn _prec ) =
(sem_TypeName_PrecTypeName _ann _tn _prec )
sem_TypeName (SetOfTypeName _ann _typ ) =
(sem_TypeName_SetOfTypeName _ann (sem_TypeName _typ ) )
sem_TypeName (SimpleTypeName _ann _tn ) =
(sem_TypeName_SimpleTypeName _ann _tn )
-- semantic domain
type T_TypeName = Catalog ->
LocalIdentifierBindings ->
( TypeName,Type,TypeName)
data Inh_TypeName = Inh_TypeName {cat_Inh_TypeName :: Catalog,lib_Inh_TypeName :: LocalIdentifierBindings}
data Syn_TypeName = Syn_TypeName {annotatedTree_Syn_TypeName :: TypeName,namedType_Syn_TypeName :: Type,originalTree_Syn_TypeName :: TypeName}
wrap_TypeName :: T_TypeName ->
Inh_TypeName ->
Syn_TypeName
wrap_TypeName sem (Inh_TypeName _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOnamedType,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_TypeName _lhsOannotatedTree _lhsOnamedType _lhsOoriginalTree ))
sem_TypeName_ArrayTypeName :: Annotation ->
T_TypeName ->
T_TypeName
sem_TypeName_ArrayTypeName ann_ typ_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOnamedType :: Type
_lhsOannotatedTree :: TypeName
_lhsOoriginalTree :: TypeName
_typOcat :: Catalog
_typOlib :: LocalIdentifierBindings
_typIannotatedTree :: TypeName
_typInamedType :: Type
_typIoriginalTree :: TypeName
-- "./TypeChecking/Misc.ag"(line 19, column 10)
_lhsOnamedType =
{-# LINE 19 "./TypeChecking/Misc.ag" #-}
tpeToT _tpe
{-# LINE 15509 "AstInternal.hs" #-}
-- "./TypeChecking/Misc.ag"(line 20, column 10)
_lhsOannotatedTree =
{-# LINE 20 "./TypeChecking/Misc.ag" #-}
updateAnnotation
((map TypeErrorA $ getErrors _tpe ) ++)
_backTree
{-# LINE 15516 "AstInternal.hs" #-}
-- "./TypeChecking/Misc.ag"(line 30, column 9)
_tpe =
{-# LINE 30 "./TypeChecking/Misc.ag" #-}
dependsOnRTpe [_typInamedType] $ Right $ ArrayType _typInamedType
{-# LINE 15521 "AstInternal.hs" #-}
-- "./TypeChecking/Misc.ag"(line 31, column 9)
_backTree =
{-# LINE 31 "./TypeChecking/Misc.ag" #-}
ArrayTypeName ann_ _typIannotatedTree
{-# LINE 15526 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
ArrayTypeName ann_ _typIannotatedTree
{-# LINE 15531 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
ArrayTypeName ann_ _typIoriginalTree
{-# LINE 15536 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 15541 "AstInternal.hs" #-}
-- copy rule (down)
_typOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 15546 "AstInternal.hs" #-}
-- copy rule (down)
_typOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 15551 "AstInternal.hs" #-}
( _typIannotatedTree,_typInamedType,_typIoriginalTree) =
(typ_ _typOcat _typOlib )
in ( _lhsOannotatedTree,_lhsOnamedType,_lhsOoriginalTree)))
sem_TypeName_PrecTypeName :: Annotation ->
String ->
Integer ->
T_TypeName
sem_TypeName_PrecTypeName ann_ tn_ prec_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOnamedType :: Type
_lhsOannotatedTree :: TypeName
_lhsOoriginalTree :: TypeName
-- "./TypeChecking/Misc.ag"(line 19, column 10)
_lhsOnamedType =
{-# LINE 19 "./TypeChecking/Misc.ag" #-}
tpeToT _tpe
{-# LINE 15569 "AstInternal.hs" #-}
-- "./TypeChecking/Misc.ag"(line 20, column 10)
_lhsOannotatedTree =
{-# LINE 20 "./TypeChecking/Misc.ag" #-}
updateAnnotation
((map TypeErrorA $ getErrors _tpe ) ++)
_backTree
{-# LINE 15576 "AstInternal.hs" #-}
-- "./TypeChecking/Misc.ag"(line 36, column 9)
_tpe =
{-# LINE 36 "./TypeChecking/Misc.ag" #-}
catLookupType _lhsIcat $ canonicalizeTypeName tn_
{-# LINE 15581 "AstInternal.hs" #-}
-- "./TypeChecking/Misc.ag"(line 37, column 9)
_backTree =
{-# LINE 37 "./TypeChecking/Misc.ag" #-}
PrecTypeName ann_ tn_ prec_
{-# LINE 15586 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
PrecTypeName ann_ tn_ prec_
{-# LINE 15591 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
PrecTypeName ann_ tn_ prec_
{-# LINE 15596 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 15601 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOnamedType,_lhsOoriginalTree)))
sem_TypeName_SetOfTypeName :: Annotation ->
T_TypeName ->
T_TypeName
sem_TypeName_SetOfTypeName ann_ typ_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOnamedType :: Type
_lhsOannotatedTree :: TypeName
_lhsOoriginalTree :: TypeName
_typOcat :: Catalog
_typOlib :: LocalIdentifierBindings
_typIannotatedTree :: TypeName
_typInamedType :: Type
_typIoriginalTree :: TypeName
-- "./TypeChecking/Misc.ag"(line 19, column 10)
_lhsOnamedType =
{-# LINE 19 "./TypeChecking/Misc.ag" #-}
tpeToT _tpe
{-# LINE 15621 "AstInternal.hs" #-}
-- "./TypeChecking/Misc.ag"(line 20, column 10)
_lhsOannotatedTree =
{-# LINE 20 "./TypeChecking/Misc.ag" #-}
updateAnnotation
((map TypeErrorA $ getErrors _tpe ) ++)
_backTree
{-# LINE 15628 "AstInternal.hs" #-}
-- "./TypeChecking/Misc.ag"(line 33, column 9)
_tpe =
{-# LINE 33 "./TypeChecking/Misc.ag" #-}
dependsOnRTpe [_typInamedType] $ Right $ SetOfType _typInamedType
{-# LINE 15633 "AstInternal.hs" #-}
-- "./TypeChecking/Misc.ag"(line 34, column 9)
_backTree =
{-# LINE 34 "./TypeChecking/Misc.ag" #-}
SetOfTypeName ann_ _typIannotatedTree
{-# LINE 15638 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
SetOfTypeName ann_ _typIannotatedTree
{-# LINE 15643 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
SetOfTypeName ann_ _typIoriginalTree
{-# LINE 15648 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 15653 "AstInternal.hs" #-}
-- copy rule (down)
_typOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 15658 "AstInternal.hs" #-}
-- copy rule (down)
_typOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 15663 "AstInternal.hs" #-}
( _typIannotatedTree,_typInamedType,_typIoriginalTree) =
(typ_ _typOcat _typOlib )
in ( _lhsOannotatedTree,_lhsOnamedType,_lhsOoriginalTree)))
sem_TypeName_SimpleTypeName :: Annotation ->
String ->
T_TypeName
sem_TypeName_SimpleTypeName ann_ tn_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOnamedType :: Type
_lhsOannotatedTree :: TypeName
_lhsOoriginalTree :: TypeName
-- "./TypeChecking/Misc.ag"(line 19, column 10)
_lhsOnamedType =
{-# LINE 19 "./TypeChecking/Misc.ag" #-}
tpeToT _tpe
{-# LINE 15680 "AstInternal.hs" #-}
-- "./TypeChecking/Misc.ag"(line 20, column 10)
_lhsOannotatedTree =
{-# LINE 20 "./TypeChecking/Misc.ag" #-}
updateAnnotation
((map TypeErrorA $ getErrors _tpe ) ++)
_backTree
{-# LINE 15687 "AstInternal.hs" #-}
-- "./TypeChecking/Misc.ag"(line 27, column 9)
_tpe =
{-# LINE 27 "./TypeChecking/Misc.ag" #-}
catLookupType _lhsIcat $ canonicalizeTypeName tn_
{-# LINE 15692 "AstInternal.hs" #-}
-- "./TypeChecking/Misc.ag"(line 28, column 9)
_backTree =
{-# LINE 28 "./TypeChecking/Misc.ag" #-}
SimpleTypeName ann_ tn_
{-# LINE 15697 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
SimpleTypeName ann_ tn_
{-# LINE 15702 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
SimpleTypeName ann_ tn_
{-# LINE 15707 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 15712 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOnamedType,_lhsOoriginalTree)))
-- TypeNameList ------------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
namedTypes : [Type]
originalTree : SELF
alternatives:
alternative Cons:
child hd : TypeName
child tl : TypeNameList
visit 0:
local annotatedTree : _
local originalTree : _
alternative Nil:
visit 0:
local annotatedTree : _
local originalTree : _
-}
type TypeNameList = [(TypeName)]
-- cata
sem_TypeNameList :: TypeNameList ->
T_TypeNameList
sem_TypeNameList list =
(Prelude.foldr sem_TypeNameList_Cons sem_TypeNameList_Nil (Prelude.map sem_TypeName list) )
-- semantic domain
type T_TypeNameList = Catalog ->
LocalIdentifierBindings ->
( TypeNameList,([Type]),TypeNameList)
data Inh_TypeNameList = Inh_TypeNameList {cat_Inh_TypeNameList :: Catalog,lib_Inh_TypeNameList :: LocalIdentifierBindings}
data Syn_TypeNameList = Syn_TypeNameList {annotatedTree_Syn_TypeNameList :: TypeNameList,namedTypes_Syn_TypeNameList :: [Type],originalTree_Syn_TypeNameList :: TypeNameList}
wrap_TypeNameList :: T_TypeNameList ->
Inh_TypeNameList ->
Syn_TypeNameList
wrap_TypeNameList sem (Inh_TypeNameList _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOnamedTypes,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_TypeNameList _lhsOannotatedTree _lhsOnamedTypes _lhsOoriginalTree ))
sem_TypeNameList_Cons :: T_TypeName ->
T_TypeNameList ->
T_TypeNameList
sem_TypeNameList_Cons hd_ tl_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOnamedTypes :: ([Type])
_lhsOannotatedTree :: TypeNameList
_lhsOoriginalTree :: TypeNameList
_hdOcat :: Catalog
_hdOlib :: LocalIdentifierBindings
_tlOcat :: Catalog
_tlOlib :: LocalIdentifierBindings
_hdIannotatedTree :: TypeName
_hdInamedType :: Type
_hdIoriginalTree :: TypeName
_tlIannotatedTree :: TypeNameList
_tlInamedTypes :: ([Type])
_tlIoriginalTree :: TypeNameList
-- "./TypeChecking/Drops.ag"(line 30, column 12)
_lhsOnamedTypes =
{-# LINE 30 "./TypeChecking/Drops.ag" #-}
_hdInamedType : _tlInamedTypes
{-# LINE 15778 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
(:) _hdIannotatedTree _tlIannotatedTree
{-# LINE 15783 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
(:) _hdIoriginalTree _tlIoriginalTree
{-# LINE 15788 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 15793 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 15798 "AstInternal.hs" #-}
-- copy rule (down)
_hdOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 15803 "AstInternal.hs" #-}
-- copy rule (down)
_hdOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 15808 "AstInternal.hs" #-}
-- copy rule (down)
_tlOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 15813 "AstInternal.hs" #-}
-- copy rule (down)
_tlOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 15818 "AstInternal.hs" #-}
( _hdIannotatedTree,_hdInamedType,_hdIoriginalTree) =
(hd_ _hdOcat _hdOlib )
( _tlIannotatedTree,_tlInamedTypes,_tlIoriginalTree) =
(tl_ _tlOcat _tlOlib )
in ( _lhsOannotatedTree,_lhsOnamedTypes,_lhsOoriginalTree)))
sem_TypeNameList_Nil :: T_TypeNameList
sem_TypeNameList_Nil =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOnamedTypes :: ([Type])
_lhsOannotatedTree :: TypeNameList
_lhsOoriginalTree :: TypeNameList
-- "./TypeChecking/Drops.ag"(line 31, column 11)
_lhsOnamedTypes =
{-# LINE 31 "./TypeChecking/Drops.ag" #-}
[]
{-# LINE 15835 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
[]
{-# LINE 15840 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
[]
{-# LINE 15845 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 15850 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 15855 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOnamedTypes,_lhsOoriginalTree)))
-- VarDef ------------------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
def : (String,Type)
originalTree : SELF
alternatives:
alternative VarDef:
child ann : {Annotation}
child name : {String}
child typ : TypeName
child value : {Maybe Expression}
visit 0:
local annotatedTree : _
local originalTree : _
-}
data VarDef = VarDef (Annotation) (String) (TypeName) (Maybe Expression)
deriving ( Data,Eq,Show,Typeable)
-- cata
sem_VarDef :: VarDef ->
T_VarDef
sem_VarDef (VarDef _ann _name _typ _value ) =
(sem_VarDef_VarDef _ann _name (sem_TypeName _typ ) _value )
-- semantic domain
type T_VarDef = Catalog ->
LocalIdentifierBindings ->
( VarDef,((String,Type)),VarDef)
data Inh_VarDef = Inh_VarDef {cat_Inh_VarDef :: Catalog,lib_Inh_VarDef :: LocalIdentifierBindings}
data Syn_VarDef = Syn_VarDef {annotatedTree_Syn_VarDef :: VarDef,def_Syn_VarDef :: (String,Type),originalTree_Syn_VarDef :: VarDef}
wrap_VarDef :: T_VarDef ->
Inh_VarDef ->
Syn_VarDef
wrap_VarDef sem (Inh_VarDef _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOdef,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_VarDef _lhsOannotatedTree _lhsOdef _lhsOoriginalTree ))
sem_VarDef_VarDef :: Annotation ->
String ->
T_TypeName ->
(Maybe Expression) ->
T_VarDef
sem_VarDef_VarDef ann_ name_ typ_ value_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOdef :: ((String,Type))
_lhsOannotatedTree :: VarDef
_lhsOoriginalTree :: VarDef
_typOcat :: Catalog
_typOlib :: LocalIdentifierBindings
_typIannotatedTree :: TypeName
_typInamedType :: Type
_typIoriginalTree :: TypeName
-- "./TypeChecking/CreateFunction.ag"(line 131, column 14)
_lhsOdef =
{-# LINE 131 "./TypeChecking/CreateFunction.ag" #-}
(name_, if _typInamedType == Pseudo Record then PgRecord Nothing else _typInamedType)
{-# LINE 15917 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
VarDef ann_ name_ _typIannotatedTree value_
{-# LINE 15922 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
VarDef ann_ name_ _typIoriginalTree value_
{-# LINE 15927 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 15932 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 15937 "AstInternal.hs" #-}
-- copy rule (down)
_typOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 15942 "AstInternal.hs" #-}
-- copy rule (down)
_typOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 15947 "AstInternal.hs" #-}
( _typIannotatedTree,_typInamedType,_typIoriginalTree) =
(typ_ _typOcat _typOlib )
in ( _lhsOannotatedTree,_lhsOdef,_lhsOoriginalTree)))
-- VarDefList --------------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
defs : [(String,Type)]
originalTree : SELF
alternatives:
alternative Cons:
child hd : VarDef
child tl : VarDefList
visit 0:
local annotatedTree : _
local originalTree : _
alternative Nil:
visit 0:
local annotatedTree : _
local originalTree : _
-}
type VarDefList = [(VarDef)]
-- cata
sem_VarDefList :: VarDefList ->
T_VarDefList
sem_VarDefList list =
(Prelude.foldr sem_VarDefList_Cons sem_VarDefList_Nil (Prelude.map sem_VarDef list) )
-- semantic domain
type T_VarDefList = Catalog ->
LocalIdentifierBindings ->
( VarDefList,([(String,Type)]),VarDefList)
data Inh_VarDefList = Inh_VarDefList {cat_Inh_VarDefList :: Catalog,lib_Inh_VarDefList :: LocalIdentifierBindings}
data Syn_VarDefList = Syn_VarDefList {annotatedTree_Syn_VarDefList :: VarDefList,defs_Syn_VarDefList :: [(String,Type)],originalTree_Syn_VarDefList :: VarDefList}
wrap_VarDefList :: T_VarDefList ->
Inh_VarDefList ->
Syn_VarDefList
wrap_VarDefList sem (Inh_VarDefList _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOdefs,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_VarDefList _lhsOannotatedTree _lhsOdefs _lhsOoriginalTree ))
sem_VarDefList_Cons :: T_VarDef ->
T_VarDefList ->
T_VarDefList
sem_VarDefList_Cons hd_ tl_ =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOdefs :: ([(String,Type)])
_lhsOannotatedTree :: VarDefList
_lhsOoriginalTree :: VarDefList
_hdOcat :: Catalog
_hdOlib :: LocalIdentifierBindings
_tlOcat :: Catalog
_tlOlib :: LocalIdentifierBindings
_hdIannotatedTree :: VarDef
_hdIdef :: ((String,Type))
_hdIoriginalTree :: VarDef
_tlIannotatedTree :: VarDefList
_tlIdefs :: ([(String,Type)])
_tlIoriginalTree :: VarDefList
-- "./TypeChecking/CreateFunction.ag"(line 134, column 12)
_lhsOdefs =
{-# LINE 134 "./TypeChecking/CreateFunction.ag" #-}
_hdIdef : _tlIdefs
{-# LINE 16015 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
(:) _hdIannotatedTree _tlIannotatedTree
{-# LINE 16020 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
(:) _hdIoriginalTree _tlIoriginalTree
{-# LINE 16025 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 16030 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 16035 "AstInternal.hs" #-}
-- copy rule (down)
_hdOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 16040 "AstInternal.hs" #-}
-- copy rule (down)
_hdOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 16045 "AstInternal.hs" #-}
-- copy rule (down)
_tlOcat =
{-# LINE 56 "./TypeChecking/TypeChecking.ag" #-}
_lhsIcat
{-# LINE 16050 "AstInternal.hs" #-}
-- copy rule (down)
_tlOlib =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_lhsIlib
{-# LINE 16055 "AstInternal.hs" #-}
( _hdIannotatedTree,_hdIdef,_hdIoriginalTree) =
(hd_ _hdOcat _hdOlib )
( _tlIannotatedTree,_tlIdefs,_tlIoriginalTree) =
(tl_ _tlOcat _tlOlib )
in ( _lhsOannotatedTree,_lhsOdefs,_lhsOoriginalTree)))
sem_VarDefList_Nil :: T_VarDefList
sem_VarDefList_Nil =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOdefs :: ([(String,Type)])
_lhsOannotatedTree :: VarDefList
_lhsOoriginalTree :: VarDefList
-- "./TypeChecking/CreateFunction.ag"(line 135, column 11)
_lhsOdefs =
{-# LINE 135 "./TypeChecking/CreateFunction.ag" #-}
[]
{-# LINE 16072 "AstInternal.hs" #-}
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
[]
{-# LINE 16077 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
[]
{-# LINE 16082 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 16087 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 16092 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOdefs,_lhsOoriginalTree)))
-- Volatility --------------------------------------------------
{-
visit 0:
inherited attributes:
cat : Catalog
lib : LocalIdentifierBindings
synthesized attributes:
annotatedTree : SELF
originalTree : SELF
alternatives:
alternative Immutable:
visit 0:
local annotatedTree : _
local originalTree : _
alternative Stable:
visit 0:
local annotatedTree : _
local originalTree : _
alternative Volatile:
visit 0:
local annotatedTree : _
local originalTree : _
-}
data Volatility = Immutable
| Stable
| Volatile
deriving ( Data,Eq,Show,Typeable)
-- cata
sem_Volatility :: Volatility ->
T_Volatility
sem_Volatility (Immutable ) =
(sem_Volatility_Immutable )
sem_Volatility (Stable ) =
(sem_Volatility_Stable )
sem_Volatility (Volatile ) =
(sem_Volatility_Volatile )
-- semantic domain
type T_Volatility = Catalog ->
LocalIdentifierBindings ->
( Volatility,Volatility)
data Inh_Volatility = Inh_Volatility {cat_Inh_Volatility :: Catalog,lib_Inh_Volatility :: LocalIdentifierBindings}
data Syn_Volatility = Syn_Volatility {annotatedTree_Syn_Volatility :: Volatility,originalTree_Syn_Volatility :: Volatility}
wrap_Volatility :: T_Volatility ->
Inh_Volatility ->
Syn_Volatility
wrap_Volatility sem (Inh_Volatility _lhsIcat _lhsIlib ) =
(let ( _lhsOannotatedTree,_lhsOoriginalTree) =
(sem _lhsIcat _lhsIlib )
in (Syn_Volatility _lhsOannotatedTree _lhsOoriginalTree ))
sem_Volatility_Immutable :: T_Volatility
sem_Volatility_Immutable =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: Volatility
_lhsOoriginalTree :: Volatility
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
Immutable
{-# LINE 16153 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
Immutable
{-# LINE 16158 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 16163 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 16168 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
sem_Volatility_Stable :: T_Volatility
sem_Volatility_Stable =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: Volatility
_lhsOoriginalTree :: Volatility
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
Stable
{-# LINE 16180 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
Stable
{-# LINE 16185 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 16190 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 16195 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))
sem_Volatility_Volatile :: T_Volatility
sem_Volatility_Volatile =
(\ _lhsIcat
_lhsIlib ->
(let _lhsOannotatedTree :: Volatility
_lhsOoriginalTree :: Volatility
-- self rule
_annotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
Volatile
{-# LINE 16207 "AstInternal.hs" #-}
-- self rule
_originalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
Volatile
{-# LINE 16212 "AstInternal.hs" #-}
-- self rule
_lhsOannotatedTree =
{-# LINE 57 "./TypeChecking/TypeChecking.ag" #-}
_annotatedTree
{-# LINE 16217 "AstInternal.hs" #-}
-- self rule
_lhsOoriginalTree =
{-# LINE 63 "./TypeChecking/TypeChecking.ag" #-}
_originalTree
{-# LINE 16222 "AstInternal.hs" #-}
in ( _lhsOannotatedTree,_lhsOoriginalTree)))