Generator returns an LLVM module

generator/generator.go

@@ -1,6 +1,5 @@
 package generator
 
-import "io"
 import "fmt"
 import "sort"
 import "errors"
@@ -29,8 +28,7 @@ func NativeTarget () Target {
 type generator struct {
 	target       Target
 	tree         analyzer.Tree
-	output       io.Writer
-	module       llvm.Module
+	module       *llvm.Module
 	
 	managerStack []*blockManager
 	blockManager *blockManager
@@ -39,32 +37,29 @@ type generator struct {
 // Generate takes in a semantic tree and writes corresponding LLVM IR to the
 // given io.Writer. It returns an error in case there is something wrong with
 // the semantic tree that prevents the code generation process from occurring.
-func (this Target) Generate (tree analyzer.Tree, output io.Writer) error {
+func (this Target) Generate (tree analyzer.Tree) (*llvm.Module, error) {
 	return (&generator {
+		module: new(llvm.Module),
 		target: this,
 		tree:   tree,
-		output: output,
 	}).generate()
 }
 
-func (this *generator) generate () error {
+func (this *generator) generate () (*llvm.Module, error) {
 	// generate typedefs
 	typedefs := sortMapKeys(this.tree.Types)
 	for _, typeName := range typedefs {
 		_, err := this.typedef(typeName)
-		if err != nil { return err }
+		if err != nil { return nil, err }
 	}
 
-	// TODO hoist and lazily generate
-	// generate functions
 	functions := sortMapKeys(this.tree.Functions)
 	for _, functionName := range functions {
 		_, err := this.function(functionName)
-		if err != nil { return err }
+		if err != nil { return nil, err }
 	}
 	
-	_, err := this.module.WriteTo(this.output)
-	return err
+	return this.module, nil
 }
 
 func (this *generator) typedef (typeName string) (llvm.Type, error) {

generator/test-common.go

@@ -28,15 +28,20 @@ func testReader (test *testing.T, correct string, inputs ...io.Reader) {
 		return
 	}
 	
+	module, err := NativeTarget().Generate(tree)
+	if err != nil {
+		test.Error("generator returned error: ", err)
+		return
+	}
 	output := new(strings.Builder)
-	err = NativeTarget().Generate(tree, output)
+	_, err = module.WriteTo(output)
 	if err != nil {
 		test.Error("generator returned error: ", err)
 		return
 	}
 	
 	got := output.String()
-	if got != correct {	
+	if got != correct {
 		test.Logf("results do not match")
 		test.Logf("got:\n%v", got)
 		test.Logf("correct:\n%v", correct)