Compile Imported Modules

[Jonathan Marler via Digitalmars-d]

Wanted to get peoples thoughts on this.  The idea is to have a 
way to tell the compiler (probably with a command line option) 
that you'd like to "compile imported modules".  Say you have a 
program "prog" that depends on modules "foo" and "bar".

     import foo;
     import bar;

Compilation could look like:

     dmd prog.d foo.d bar.d

Or it could look like

     dmd -c foo.d
     dmd -c bar.d
     dmd prog.d foo.obj bar.obj

With this command line option, let's call it "-compile-imports" 
for now, you could do something like:

     dmd -compile-imports prog.d

This tells the compiler that after it has processed all the input 
files (source code/object files/library files), if it is missing 
modules, it should go back and look for those modules in it's 
list of imported modules, then compile them from there.  It's 
important that it only checks this after processing all the input 
files so that precompiled modules take precedence.  So you could 
still do something like this:

     dmd -c foo.d
     dmd -compile-imports prog.d foo.obj

In this example we use the precompiled foo module and then the 
compiler notices that the bar module is missing.  So it looks for 
the source in it's list of imports, then includes that in it's 
list of files to compile essentialy behaving as if that file was 
passed on the command line.

This is a simple example with only 2 modules, but for projects 
that use alot of libraries it could turn into something like this:

     dmd prog.d -Isomelib somelib\foo\module1.d 
somelib\foo\module2.d somelib\foo\module3.d somelib\foo\module4.d 
somelib\foo\module5.d somelib\foo\module6.d -Ianotherlib 
anotherlib\bar\module1.d anotherlib\bar\module2.d 
anotherlib\bar\module3.d anotherlib\bar\module4.d 
anotherlib\bar\module5.d

into this:

     dmd -compile-imports prog.d -Isomelib -Ianotherlib

This would also simplify rdmd and make it "less brittle" because 
it will not need to duplicate the logic inside the compiler that 
locates and selects which module files to compile.  Instead, it 
can simply use the -compile-imports switch leave that logic 
completely in the compiler.