ATTR Module
   [   dictionaryEnv    : DictionaryEnvironment
       extraDecls       : { [Core.CoreDecl] }
       importEnv        : ImportEnvironment
       toplevelTypes    : TypeEnvironment
   |
   |   core             : { Core.CoreModule }
   ]

-- UHA
INCLUDE "UHA_Syntax.ag"

-- Transformation into Core
INCLUDE "ToCoreModule.ag"
INCLUDE "ToCoreDecl.ag"
INCLUDE "ToCoreExpr.ag"
INCLUDE "ToCorePat.ag"
INCLUDE "ToCoreName.ag"

imports{
import Helium.Syntax.UHA_Syntax
import Helium.Syntax.UHA_Utils
import Helium.Syntax.UHA_Range 
import Helium.ModuleSystem.ImportEnvironment
import Helium.ModuleSystem.DictionaryEnvironment
import qualified Data.Map as M
import Helium.StaticAnalysis.Miscellaneous.TypeConversion
import Data.Char (ord)


import Lvm.Common.Id
import Lvm.Common.IdSet 
import Helium.Utils.Utils(internalError)

import Top.Types

import Helium.CodeGeneration.PatternMatch
import qualified Helium.CodeGeneration.DerivingShow as DerivingShow
import qualified Helium.CodeGeneration.DerivingEq as DerivingEq

-- Semi-Daan
import Helium.CodeGeneration.CoreUtils

-- Daan
import qualified Lvm.Core.Expr as Core
import qualified Lvm.Core.Module as Core
import qualified Lvm.Core.Module as Module
import qualified Lvm.Common.Byte as Byte
}

{

type CoreDecl = Core.Decl Core.Expr
}

--Collect.ag

ATTR Body Declarations Declaration Expressions Expression Statements Statement
     Qualifiers Qualifier GuardedExpressions GuardedExpression 
     Alternatives Alternative FunctionBindings FunctionBinding
     RightHandSide MaybeDeclarations MaybeExpression RecordExpressionBinding
     RecordExpressionBindings Constructors Constructor
    [ dictionaryEnv : DictionaryEnvironment | | ]

ATTR Body Declarations Declaration Constructor Constructors
    [ importEnv     : ImportEnvironment | | ]
    
SEM Expression        | Let  loc.importEnv = internalError "CodeGeneration.ag" "Expression.Let" ""
SEM MaybeDeclarations | Just loc.importEnv = internalError "CodeGeneration.ag" "MaybeDeclarations.Just" ""      
SEM Qualifier         | Let  loc.importEnv = internalError "CodeGeneration.ag" "Qualifier.Let" ""       
SEM Statement         | Let  loc.importEnv = internalError "CodeGeneration.ag" "Statement.Let" ""       

ATTR SimpleType [ | | name:Name typevariables:Names ]

SEM SimpleType
  | SimpleType  lhs . name          = @name.self                   
                    . typevariables = @typevariables.self