| 1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889 |
- When and how to create/read interface files
- -------------------------------------------
- We need information from imports twice: at scope checking, and at type checking.
- We can go about this in a few different ways:
- - read interface file twice, first at scope checking (possibly creating it) and second
- at type checking
- - read the interface once, and store the type information for use at type
- checking time
- Other concerns
- --------------
- - What happens when we do import from inside a parameterised module? Top-level
- modules can be parameterised.
- - The imported module exists outside the parameterised module, so it shouldn't
- be affected by the parameters.
- - Can we do imports anywhere? Does it make sense. Probably, but is it a good
- thing? Options:
- - imports anywhere
- - only in top-level module
- - only first in top-level module (Haskell-style)
- - before the top-level module (java-style)
- Let's stick with imports anywhere for the time being.
- Technical issues
- ----------------
- - How should it work?
- - The interface file simply stores a representation of the internal state
- (ScopeInfo and Signature). When importing a module we just read the
- interface file and merge the corresponding internal thing into the current
- state.
- - We need to keep track of what things come from the current module, and what
- things come from imported modules. In the final version we don't want to store
- things from an imported module in the interface for a module. But rather store
- a reference to the imported module. This of course means that reading an
- interface file might require the reading of other interface files. We need
- cycle detection.
- - First step should be to change the Signature and ScopeInfo to account for
- imported modules, making sure we recognise what's part of the current module
- and what is imported.
- - In scope checking we need to store the ModuleScope. This means that there
- should be a function to extract the ModuleScope of the current module from the
- ScopeInfo.
- - Now what?
-
- Making the type checking monad aware of imports:
- - separate signatures for imported modules and other modules
- - look up things in both signatures. exactly one lookup must succeed.
- - we play around with the signature in a lot of places? what needs to be
- changed to handle the imported signature? don't know, i guess we'll see...
- - What does the interface file need to contain?
- - ModuleScope
- - Signature
- - BuiltinThings
- - names of imported modules
- - Issues
- - primitive functions: we can't store type-checking computations in the
- interface file. So we need a different representation. What?
- - remember which module have been imported, so that we don't load the same
- interface several times. Or don't care? If we want to check for clashes we
- might want to do this.
- vim: tw=80 sts=2 sw=2 fo+=t com=f\:-
|
