| 1 | (* Copyright (C) 2017 Matthew Fluet. |
| 2 | * Copyright (C) 1999-2008 Henry Cejtin, Matthew Fluet, Suresh |
| 3 | * Jagannathan, and Stephen Weeks. |
| 4 | * Copyright (C) 1997-2000 NEC Research Institute. |
| 5 | * |
| 6 | * MLton is released under a BSD-style license. |
| 7 | * See the file MLton-LICENSE for details. |
| 8 | *) |
| 9 | |
| 10 | signature ELABORATE_ENV_STRUCTS = |
| 11 | sig |
| 12 | structure Ast: AST |
| 13 | structure CoreML: CORE_ML |
| 14 | structure TypeEnv: TYPE_ENV |
| 15 | sharing Ast.Record = CoreML.Record |
| 16 | sharing Ast.SortedRecord = CoreML.SortedRecord |
| 17 | sharing CoreML.Atoms = TypeEnv.Atoms |
| 18 | sharing CoreML.Type = TypeEnv.Type |
| 19 | end |
| 20 | |
| 21 | signature ELABORATE_ENV = |
| 22 | sig |
| 23 | include ELABORATE_ENV_STRUCTS |
| 24 | |
| 25 | structure Decs: DECS |
| 26 | sharing CoreML = Decs.CoreML |
| 27 | |
| 28 | structure Tyvar: TYVAR |
| 29 | sharing Tyvar = TypeEnv.Tyvar |
| 30 | structure TyvarEnv: |
| 31 | sig |
| 32 | val lookupTyvar: Ast.Tyvar.t -> Tyvar.t option |
| 33 | val scope: Ast.Tyvar.t vector * (Tyvar.t vector -> 'a) -> 'a |
| 34 | val makeLayoutPretty: unit -> {destroy: unit -> unit, layoutPretty: Tyvar.t -> Layout.t} |
| 35 | end |
| 36 | |
| 37 | structure AdmitsEquality: ADMITS_EQUALITY |
| 38 | sharing AdmitsEquality = TypeEnv.Tycon.AdmitsEquality |
| 39 | structure Kind: TYCON_KIND |
| 40 | sharing Kind = TypeEnv.Tycon.Kind |
| 41 | structure Tycon: TYCON |
| 42 | sharing Tycon = TypeEnv.Tycon |
| 43 | |
| 44 | structure Type: |
| 45 | sig |
| 46 | type t |
| 47 | end |
| 48 | sharing Type = TypeEnv.Type |
| 49 | structure Scheme: |
| 50 | sig |
| 51 | type t |
| 52 | end |
| 53 | sharing Scheme = TypeEnv.Scheme |
| 54 | |
| 55 | (* The value of a vid. This is used to distinguish between vids whose |
| 56 | * status cannot be determined at parse time. |
| 57 | *) |
| 58 | structure Vid: |
| 59 | sig |
| 60 | datatype t = |
| 61 | Con of CoreML.Con.t |
| 62 | | Exn of CoreML.Con.t |
| 63 | | Overload of Ast.Priority.t * (CoreML.Var.t * Scheme.t) vector |
| 64 | | Var of CoreML.Var.t |
| 65 | |
| 66 | val layout: t -> Layout.t |
| 67 | end |
| 68 | |
| 69 | structure TypeStr: |
| 70 | sig |
| 71 | structure Cons: |
| 72 | sig |
| 73 | type t |
| 74 | |
| 75 | val layout: t -> Layout.t |
| 76 | end |
| 77 | |
| 78 | type t |
| 79 | |
| 80 | datatype node = |
| 81 | Datatype of {cons: Cons.t, |
| 82 | tycon: Tycon.t} |
| 83 | | Scheme of Scheme.t |
| 84 | | Tycon of Tycon.t |
| 85 | |
| 86 | val abs: t -> t |
| 87 | val admitsEquality: t -> AdmitsEquality.t |
| 88 | val apply: t * Type.t vector -> Type.t |
| 89 | val data: Tycon.t * Cons.t -> t |
| 90 | val def: Scheme.t -> t |
| 91 | val kind: t -> Kind.t |
| 92 | val layout: t -> Layout.t |
| 93 | val node: t -> node |
| 94 | val toTyconOpt: t -> Tycon.t option (* NONE on Scheme *) |
| 95 | val tycon: Tycon.t -> t |
| 96 | end |
| 97 | |
| 98 | structure Interface: INTERFACE |
| 99 | sharing Interface.Ast = Ast |
| 100 | sharing Interface.AdmitsEquality = AdmitsEquality |
| 101 | sharing Interface.Kind = Kind |
| 102 | sharing Interface.EnvTycon = Tycon |
| 103 | sharing Interface.EnvTypeStr = TypeStr |
| 104 | sharing Interface.Tyvar = Tyvar |
| 105 | |
| 106 | structure Structure: |
| 107 | sig |
| 108 | type t |
| 109 | |
| 110 | (* ffi represents MLtonFFI, which is built by the basis library and |
| 111 | * set via the special ffiStr MLB annotation. |
| 112 | *) |
| 113 | val ffi: t option ref |
| 114 | val forceUsed: t -> unit |
| 115 | val layout: t -> Layout.t |
| 116 | end |
| 117 | structure FunctorClosure: |
| 118 | sig |
| 119 | type t |
| 120 | |
| 121 | val apply: (t * Structure.t * string list |
| 122 | -> Decs.t * Structure.t option) |
| 123 | val argInterface: t -> Interface.t |
| 124 | end |
| 125 | |
| 126 | structure InterfaceEnv: |
| 127 | sig |
| 128 | structure FlexibleTycon: |
| 129 | sig |
| 130 | type t |
| 131 | end |
| 132 | structure Scheme: |
| 133 | sig |
| 134 | type t |
| 135 | end |
| 136 | structure Status: |
| 137 | sig |
| 138 | type t |
| 139 | end |
| 140 | structure TypeStr: |
| 141 | sig |
| 142 | type t |
| 143 | end |
| 144 | |
| 145 | type t |
| 146 | |
| 147 | val extendCon: t * Ast.Con.t * Scheme.t -> unit |
| 148 | val extendExn: t * Ast.Con.t * Scheme.t -> unit |
| 149 | val extendStrid: t * Ast.Strid.t * Interface.t -> unit |
| 150 | val extendTycon: t * Ast.Tycon.t * TypeStr.t -> unit |
| 151 | val extendVid: t * Ast.Vid.t * Status.t * Scheme.t -> unit |
| 152 | val lookupLongtycon: t * Ast.Longtycon.t -> TypeStr.t option |
| 153 | val lookupSigid: t * Ast.Sigid.t -> Interface.t option |
| 154 | val makeInterface: |
| 155 | t * {isTop: bool} * (unit -> 'a) -> Interface.t * 'a |
| 156 | val openInterface: t * Interface.t * Region.t -> unit |
| 157 | val rebindTycon: t * Ast.Tycon.t * TypeStr.t -> unit |
| 158 | end |
| 159 | sharing Interface.FlexibleTycon = InterfaceEnv.FlexibleTycon |
| 160 | sharing Interface.Scheme = InterfaceEnv.Scheme |
| 161 | sharing Interface.Status = InterfaceEnv.Status |
| 162 | sharing Interface.TypeStr = InterfaceEnv.TypeStr |
| 163 | |
| 164 | structure Basis: |
| 165 | sig |
| 166 | type t |
| 167 | val layout: t -> Layout.t |
| 168 | end |
| 169 | |
| 170 | type t |
| 171 | |
| 172 | val amInsideFunctor: unit -> bool |
| 173 | (* cut keeps only those bindings in the structure that also appear |
| 174 | * in the interface. It proceeds recursively on substructures. |
| 175 | *) |
| 176 | val cut: |
| 177 | t * Structure.t * Interface.t |
| 178 | * {isFunctor: bool, opaque: bool, prefix: string} * Region.t |
| 179 | -> Structure.t * Decs.t |
| 180 | val empty: unit -> t |
| 181 | val extendBasid: t * Ast.Basid.t * Basis.t -> unit |
| 182 | val extendExn: t * Ast.Con.t * CoreML.Con.t * Scheme.t -> unit |
| 183 | val extendFctid: t * Ast.Fctid.t * FunctorClosure.t -> unit |
| 184 | val extendFix: t * Ast.Vid.t * Ast.Fixity.t -> unit |
| 185 | val extendSigid: t * Ast.Sigid.t * Interface.t -> unit |
| 186 | val extendStrid: t * Ast.Strid.t * Structure.t -> unit |
| 187 | val extendTycon: |
| 188 | t * Ast.Tycon.t * TypeStr.t * {forceUsed: bool, isRebind: bool} -> unit |
| 189 | val extendVar: |
| 190 | t * Ast.Var.t * CoreML.Var.t * Scheme.t * {isRebind: bool} -> unit |
| 191 | val extendOverload: |
| 192 | t * Ast.Priority.t * Ast.Var.t * (CoreML.Var.t * Scheme.t) vector |
| 193 | * Scheme.t |
| 194 | -> unit |
| 195 | val forceUsed: t -> unit |
| 196 | val forceUsedLocal: t * (unit -> 'a) -> 'a |
| 197 | val functorClosure: |
| 198 | t * Ast.Fctid.t * Interface.t |
| 199 | * (Structure.t * string list -> Decs.t * Structure.t option) |
| 200 | -> FunctorClosure.t |
| 201 | val localAll: t * (unit -> 'a) * ('a -> 'b) -> 'b |
| 202 | val localCore: t * (unit -> 'a) * ('a -> 'b) -> 'b |
| 203 | val localModule: t * (unit -> 'a) * ('a -> 'b) -> 'b |
| 204 | val lookupBasid: t * Ast.Basid.t -> Basis.t option |
| 205 | val lookupFctid: t * Ast.Fctid.t -> FunctorClosure.t option |
| 206 | val lookupLongcon: t * Ast.Longcon.t -> (CoreML.Con.t * Scheme.t) option |
| 207 | val lookupLongexn: t * Ast.Longcon.t -> (CoreML.Con.t * Scheme.t) option |
| 208 | val lookupLongstrid: t * Ast.Longstrid.t -> Structure.t option |
| 209 | val lookupLongtycon: t * Ast.Longtycon.t -> TypeStr.t option |
| 210 | val lookupLongvar: t * Ast.Longvar.t -> (CoreML.Var.t * Scheme.t) option |
| 211 | val lookupLongvid: t * Ast.Longvid.t -> (Vid.t * Scheme.t) option |
| 212 | val lookupSigid: t * Ast.Sigid.t -> Interface.t option |
| 213 | val lookupStrid: t * Ast.Strid.t -> Structure.t option |
| 214 | val makeBasis: t * (unit -> 'a) -> 'a * Basis.t |
| 215 | val makeInterfaceEnv: t -> InterfaceEnv.t |
| 216 | val makeStructure: t * (unit -> 'a) -> 'a * Structure.t |
| 217 | val newCons: |
| 218 | t * {con: CoreML.Con.t, |
| 219 | name: Ast.Con.t, |
| 220 | scheme: Scheme.t} vector |
| 221 | -> TypeStr.Cons.t |
| 222 | (* openStructure (E, S) opens S in the environment E. *) |
| 223 | val openStructure: t * Structure.t -> unit |
| 224 | (* openBasis (E, B) opens B in the environment E. *) |
| 225 | val openBasis: t * Basis.t -> unit |
| 226 | val output: t * Out.t * {compact: bool, def: bool, flat: bool, onlyCurrent: bool, prefixUnset: bool} -> unit |
| 227 | val peekFix: t * Ast.Vid.t -> Ast.Fixity.t option |
| 228 | val peekLongcon: t * Ast.Longcon.t -> (CoreML.Con.t * Scheme.t) option |
| 229 | val processDefUse: t -> unit |
| 230 | (* scope f evaluates f () in a new scope so that extensions that occur |
| 231 | * during f () are forgotten afterwards. |
| 232 | * scope works for infixes, types, values, and structures |
| 233 | *) |
| 234 | val scope: t * (unit -> 'a) -> 'a |
| 235 | (* like scope, but works for bases, signatures and functors as well *) |
| 236 | val scopeAll: t * (unit -> 'a) -> 'a |
| 237 | val makeLayoutPrettyTycon: |
| 238 | t * {prefixUnset: bool} |
| 239 | -> {destroy: unit -> unit, |
| 240 | layoutPrettyTycon: Tycon.t -> Layout.t, |
| 241 | setLayoutPrettyTycon: Tycon.t * Layout.t -> unit, |
| 242 | loopStr: Structure.t * int * Ast.Strid.t list -> unit} |
| 243 | val makeLayoutPrettyTyconAndFlexTycon: |
| 244 | t * InterfaceEnv.t * Interface.t option * {prefixUnset: bool} |
| 245 | -> {destroy: unit -> unit, |
| 246 | layoutPrettyTycon: Tycon.t -> Layout.t, |
| 247 | layoutPrettyFlexTycon: Interface.FlexibleTycon.t -> Layout.t, |
| 248 | setLayoutPrettyTycon: Tycon.t * Layout.t -> unit} |
| 249 | val sizeMessage: t -> Layout.t |
| 250 | val snapshot: t -> (unit -> 'a) -> 'a |
| 251 | end |